He was thin in the way that suggested he'd been burning more calories than he consumed for a while. His desk was organized chaos - neat stacks of paper, labeled folders, a laptop running some kind of spreadsheet application. Behind him, a whiteboard covered in timeline diagrams and what looked like entity behavior flowcharts.
His status screen showed Level 4 Logician, Strategist archetype. Higher level than Marcus, but the same base class. That meant similar skill trees, similar cognitive strengths.
Good, Marcus thought. He'll understand documentation methodology without me having to explain it.
Chen looked up as Marcus approached. His eyes did that quick assessment thing that people did now - checking for threat level, class designation, competency markers.
"Webb," Chen said without preamble. "The QA guy who figured out lane markings."
"That's me."
"Sit." Chen gestured to a chair that looked salvaged from a dorm room. "Tell me what you did before the System, specifically. Don't give me the LinkedIn version. Give me the actual work."
Marcus sat. "Software testing at Nexus. Enterprise applications, some consumer products. I wrote test cases, executed them, documented bugs, validated fixes. Regression testing, integration testing, edge case identification."
"How long?"
"Ten years. Started as junior QA, worked my way up to senior test engineer."
"Why didn't you move into development?"
Direct question. Probably a test to see if Marcus would bullshit him.
"Because I was better at finding problems than solving them. And because I hate coding. Testing lets you be the person who points at broken shit and says 'this doesn't work,' which is more satisfying than being the person who has to fix it."
Chen's mouth twitched. Might have been a smile. "Kira said you had a theory about the System being software."
"Not a theory. An observation. The System has version numbers on skills. Uses developer terminology. Exhibits bugs consistent with production software that shipped before it was ready. Someone built this thing. Which means it has all the problems that built things have."
"And you think you can exploit those problems."
"I think if it's software, it has rules. And rules can be learned. Some of those rules will have edge cases. And edge cases can be exploited." Marcus leaned forward slightly. "The lane marking thing isn't magic. It's lazy implementation. The System repurposed road geometry data as pathfinding constraints because it was easier than building new navigation from scratch. That's the kind of shortcut developers take when they're trying to ship fast."
Chen was quiet for a long moment, studying Marcus with the intensity of someone evaluating a risky hire.
"How much time do you have left?" Chen finally asked.
"Sixty-seven hours. Give or take."
"That's rough." Chen said it the way Kira had - acknowledgment without sympathy, because sympathy didn't change countdown timers. "You understand that if you work with the analysis team, you'll be spending your last sixty-seven hours staring at spreadsheets instead of enjoying whatever apocalypse tourism appeals to you."
"I spent the last three weeks in my apartment documenting System bugs instead of evacuating. I'm not good at apocalypse tourism."
"Fair." Chen slid a stack of papers across the desk. "This is everything we've collected about System mechanics. Observations from scouts, combat logs, resource tracking. Deprecation patterns." He tapped the top sheet. "Read it tonight. Tomorrow morning, you tell me what we're missing."
Marcus picked up the stack. Had to be three hundred pages, minimum. "You want analysis of three hundred pages in one night?"
"I want to know if you're actually good at finding patterns or if you just got lucky with the lane markings." Chen's expression was flat, unreadable. "We don't have time for people who can't pull their weight. You've got sixty-seven hours to prove you're worth the bunk space and the food rations."
Ah. Performance review. Got it.
"Understood," Marcus said.
"One more thing." Chen pulled up something on his laptop, turned the screen so Marcus could see. It was a timeline diagram, x-axis showing dates, y-axis showing... something. Markers at regular intervals. "What do you see?"
Marcus studied it. The markers were evenly spaced. Too evenly to be random. "Periodic events. Regular intervals. What's the data?"
"Deprecation notices. Every instance we've documented across the cluster." Chen zoomed in. "What's the pattern?"
Marcus looked closer. The timestamps were all clustered around the same time of day. "They're synchronized. All the deprecation notices hit at approximately the same time."
"Not approximately. Exactly." Chen highlighted a column of numbers. "Every deprecation notice in our dataset was sent at 11:47:23 UTC. Down to the second."
Marcus felt his pulse quicken. That wasn't batch processing. That was scheduled processing.
"Could be a cron job," Marcus said slowly.
Chen leaned back, fingers steepled. "That was my first thought too. But what's your alternative hypothesis? What else could cause that pattern?"
Marcus thought for a moment. "Triggered event. Something hits a threshold, fires a batch process. But the timing's too precise for that - triggered events have variance based on when the threshold gets hit."
"Agreed. What else?"
"Manual processing? Someone - or something - reviewing a queue at a specific time each day?"
"Possible," Chen acknowledged. "But that implies intentionality. A scheduler. Which leads us back to automation."
Marcus nodded, seeing where Chen was going. "So if it's automated and that precise, it's either a cron job or something functionally equivalent. A scheduled task."
"Exactly." Chen's eyes had that gleam of someone who'd found a fellow pattern-matcher. "And if it's scheduled, there are implications. Talk me through them."
Marcus felt his brain shift into analysis mode. This was collaborative debugging now, not lecturing. "If it runs on a schedule, there's a queue. Structures get added to the queue based on some criteria, then processed in batch when the job runs."
"Which means?"
"There's a window between flagging and processing. If we can detect when structures enter the queue-"
"-we might be able to intervene before the deprecation notice goes out," Chen finished. "Prevention rather than evacuation."
Stolen story; please report.
"But we need to understand the flagging criteria. What makes the System mark a structure as deprecated?"
"That's your first real test, Webb. Figure out the selection logic." Chen closed the laptop. "Your carrel is by the east window. Third one from the left. Don't touch anyone else's workspace. Don't share your findings until we've verified them. And don't stay up all night - exhaustion penalties will kill your PER stat, and you need that for analysis work."
Marcus took the stack of papers and headed for his assigned carrel.
Behind him, Chen had already returned to his laptop, fingers flying across the keyboard. The man worked like someone who knew exactly how much time he didn't have.
Marcus understood that feeling.
The carrel by the east window was small but functional.
Someone - probably Julie, based on the neat labeling system - had set it up with supplies: pens, highlighters, sticky notes, a legal pad. A desk lamp that ran off the building's emergency power. A charging cable for his phone. The chair was surprisingly comfortable, probably salvaged from a professor's office rather than the student study furniture.
Through the window, Marcus could see part of the UT tower and the cluster's western barricades. People moving. Guards patrolling. The constant low-level activity of a community trying to survive.
He sat down, arranged the papers, and started reading.
The documentation was better than Marcus had expected.
Someone - probably Chen or Julie - had implemented actual data collection methodology. Each observation was dated, timed, and included the observer's name and class. Entity encounters had location data, behavior notes, outcome tracking. Deprecation notices included exact timestamps, structure IDs, estimated occupancy.
Marcus started with the deprecation data. Seventeen confirmed instances across Austin, all documented with the same level of detail:
Structure: Building 12 (East Austin residential)
- Notice received: Day 19, 11:47:23 UTC (5:47 AM local)
- Occupancy: ~12 users (estimated)
- Evacuation: 8 confirmed, 4 unknown status
- Deprecation completed: Day 22, 11:51:46 UTC (4m 23s processing time)
- Current status: Physically intact, flagged as invalid position
Structure: ATX-E-4471 (East Austin residential)
- Notice received: Day 21, 11:47:23 UTC (5:47 AM local)
- Occupancy: 1 confirmed user (Marcus Webb)
- Evacuation: 1 confirmed
- Status: In progress (47h remaining as of this report)
Seeing his own building listed in the dataset was surreal. Someone had documented his deprecation notice. Tracked his evacuation. Recorded him as data.
I'm a data point now, Marcus thought. User ID, Class designation, Outcome: TBD.
He kept reading.
The timestamp pattern was consistent across all seventeen instances. Every single deprecation notice: 11:47:23 UTC. No variance. No drift. Exactly the same time, down to the second.
That wasn't how batch processing worked. Batch jobs had queue delays, processing variance, resource contention. You might get similar times, but not identical times across multiple days unless-
Unless it was a scheduled job. A cron expression. Something that fired at exactly 11:47 UTC every day because someone had hardcoded it that way.
Marcus pulled up his phone's calculator and started working through the timezone math.
11:47 UTC was 5:47 AM in Central Time (Austin).
But there was also a report from El Paso - Mountain Time zone.
El Paso deprecation notice: 11:47:23 UTC, displayed as 5:47 AM local.
Wait. That was wrong.
11:47 UTC in Mountain Time was 4:47 AM local, not 5:47 AM.
Unless...
Marcus checked the date stamps. The El Paso report was from after the fall time change. Daylight saving time had ended on Day 14 of the System integration.
He did the math again. During daylight saving time, Mountain Time was UTC-6. After the time change, it was UTC-7.
11:47 UTC during DST = 5:47 AM Mountain Daylight Time.
11:47 UTC after DST = 4:47 AM Mountain Standard Time.
So if the El Paso report showed 5:47 AM, it was from during DST. Which meant the System was adjusting for local time zones correctly.
But why display local time at all? The System used UTC for everything else. Quest timers. Review cycles. Server timestamps.
Hypothesis: The deprecation notices are localized for user display, but the underlying process runs on UTC. Which means the System is translating timestamp data at the UI layer.
That was actually decent UX design. Show users time in their local context, but maintain consistency in the backend.
It also meant the timing was even more suspicious. If the System was bothering to localize timestamps, it was because someone had implemented that feature deliberately. Which suggested the timing mattered. 5:47 AM local time wasn't random - it was chosen.
Why 5:47 AM?
Early morning. Most people would be asleep. Minimal disruption to daily cycles.
Or: optimal time for overnight batch processing. Run expensive operations during low-activity periods.
Marcus made notes on the legal pad:
DEPRECATION TIMING ANALYSIS
- All notices: exactly 11:47:23 UTC
- No variance across 17 documented instances
- Implies scheduled job, not batch processing
- Local time display: 5:47 AM (after timezone adjustment)
Questions:
- Why 11:47? (specific time choice suggests intentionality)
- Why 23 seconds past the minute? (offset from round number)
- How are structures selected for deprecation?
- Is there a queue? If so, when are structures added to it?
He needed more data. The seventeen deprecation notices were good, but they only showed the output of the process. Marcus needed to understand the input - what criteria triggered a structure to be flagged.
He dug through the papers until he found the section labeled "Structure Status Tracking."
The structure data was messier than the deprecation notices.
Someone had tried to track building status across the cluster's territory, but it was clearly incomplete. Field observations from scouts, dated and timed, but with inconsistent detail:
Day 14 - East 4th Street, Block A
- 8 residential structures surveyed
- 3 actively occupied (confirmed user activity)
- 4 empty (no recent signs of use)
- 1 deprecated (Building 12)
Notes: Empty structures show no maintenance activity. No lights, no movement, no resource gathering observed.
Day 17 - Mueller District, Sector 3
- 12 structures surveyed
- 2 actively occupied
- 9 empty
- 1 recently deprecated (Mueller-E-3382)
Notes: Deprecated structure was unoccupied for at least 5 days prior to notice.
Marcus started highlighting patterns.
Empty structures. Low activity. No maintenance. No user presence.
Every structure that had received a deprecation notice shared those characteristics. They'd been abandoned. Left empty for days. No lights, no movement, no signs of ongoing use.
The pattern was clear: the System was targeting abandoned structures.
But why?
Resource optimization, Marcus thought. The System maintains physical infrastructure - power, water, structural integrity. That costs processing power. Why maintain structures that nobody's using?
It was the same logic cloud providers used. Idle instances got flagged for termination. Unused resources got reclaimed. Pay for what you use, and if you're not using it, the system assumes you don't need it.
The System was treating buildings like computing resources. Usage-based allocation. Deprecate what's not actively maintained.
Which meant the selection criteria was probably based on activity metrics. User presence. Power consumption. Movement within the structure. Resource gathering. Any signal that indicated the building was serving a function.
And if structures were flagged based on activity metrics, that meant there was a window - a period between "low activity detected" and "deprecation notice issued" where the structure was at risk but not yet condemned.
The queue, Marcus realized. Structures get added to the queue when activity drops below threshold. Then the queue gets processed once per day at 11:47 UTC.
He flipped through more papers, looking for activity tracking on structures that hadn't been deprecated. The cluster's occupied buildings. The ones that were safe.
UT Cluster - Core Territory Status (Day 19)
- 47 structures actively maintained
- ~200 users distributed across housing
- Constant activity: foot traffic, resource gathering, guard rotations
- Power usage: high (emergency generators, lighting, laptops)
Status: No deprecation notices received on any core structure
High activity. Constant user presence. Power consumption. All the signals that told the System: this infrastructure is in use, don't reclaim it.
Marcus started connecting the dots on his legal pad:
DEPRECATION TRIGGER HYPOTHESIS
System monitors structure activity metrics:
- User presence (movement, occupation)
- Power consumption
- Resource gathering
- Maintenance actions
When metrics fall below threshold → structure flagged for deprecation
Flagged structures added to queue
Queue processed daily at 11:47:23 UTC
Notices sent, 72-hour countdown begins
CRITICAL INSIGHT: There's a window between flagging and notice
If we can detect when structures enter "at-risk" state...
If we can increase activity before notice is sent...
We might be able to PREVENT deprecation
His hands were shaking slightly. Not from fear - from the adrenaline rush of finding a real, exploitable pattern.
This wasn't just documentation. This was actionable intelligence.
If the cluster's buildings started showing low activity, they could intervene before the deprecation notice hit. Move people in. Increase power usage. Generate traffic. Keep the activity metrics above the flagging threshold.
And if individual users' buildings were at risk - if someone's apartment was flagged because they'd evacuated - they might be able to reverse it by returning and increasing activity.
It wasn't a perfect solution. Marcus still didn't know the exact threshold values. Didn't know how long structures had to be inactive before flagging occurred. Didn't know if activity increases could remove structures from the queue after they'd been flagged.
But it was something. A theory that could be tested. A potential exploit that could save lives.
Marcus checked his deprecation timer: 65 hours, 42 minutes remaining.
He gathered his notes and went to find Chen.