Recruiters and hiring systems now use automated AI filters to read everything you have posted online—your public GitHub code, social posts, and blog essays—and draw conclusions about your personality and skill focus.[1] Previously, reviewing a candidate's digital history required manual human research. Today, cheap large language models (LLMs) and automated text parsers allow automated systems to continuously scan, summarize, and score your digital footprint at consumer scale.
Hiring systems are not uniform; they evaluate you based on different rules. For example, automated applicant tracking software evaluates resumes using keyword matches; background check vendors search public registries; and venture capitalists look at code contributions and essays. The main problem is that while you can see your own posts, you remain completely blind to the hidden conclusions and scores these systems calculate about you.
Your main online reputation risk is no longer simple data theft, but how automated systems judge your digital footprint. Optic is a tool that runs entirely inside your browser to simulate these filters and show you exactly where you trigger alerts. The system processes your online profiles client-side, highlights which specific posts trigger flags, displays the estimated confidence margins, and suggests concrete changes to fix them. Your personal profiles are stored securely on your own device (Hush Vault) using local text filters to scrub private details like phone numbers and emails before any cloud data transit.
This document describes how the Optic software works, explained through five core insights:
1. Deleting your data does not protect your reputation. Once your posts are published, automated systems copy, cache, and analyze them. Since you cannot delete everything, you must instead understand how these models interpret your footprint and actively adjust what they see to prevent opportunity loss.
2. AI filters make mistakes because they lack context. For example, if you write advanced graphics code and also publish biology essays, a corporate screening tool might compress these high-variance signals and flag you as "unfocused and likely to quit." However, a seed venture capitalist looking for non-traditional founders might see the exact same posts as "original genius." Optic simulates these different audiences so you can fix signals before applying.
3. Testing your reputation against specific systems. Optic is an automated self-audit. We test your profiles against three main scenarios: automated resume parsers, background screening companies, and public context collapse (where posts meant for friends are read out-of-context by employers).
4. Built for people with non-traditional proof. This tool is designed for founders raising seed capital, programmers without formal credentials, and career changers. These people have highly valuable but non-linear digital trails that get automatically filtered out by rigid corporate software.
5. Core features roadmap. Our software release plan is focused and clear:
• v1 (Active Sandbox): A tool that generates a private report showing you your top 5 reputation flags, the specific posts that caused them, and step-by-step suggestions to fix them.
• v2: A fully interactive interface to edit or redact specific online traces.
• v3: Active local monitors that alert you when a new post might trigger filters.
• v4-v5: Tools to securely share your corrected, verified profiles with employers.
To demonstrate the active capabilities of the Optic State Model, the following report houses a high-fidelity conceptual diagnostic flow.
Choose a profile below to simulate how automated AI hiring filters scan public data and show what they conclude about you. Raw personal files are processed securely inside your web browser.
Scroll down to inspect the Stacked Sheets of the Diagnostic Audit...
Optic processes your public online footprints (commits, posts, and resume entries) to calculate two key metrics: **Proof Density** (verifiable proof of building) and **Narrative Coherence** (how consistent your career story is). For interface visualization, we project these parameters onto a two-dimensional grid, though the full system tracks ten distinct metrics, including execution speed, originality, recent activity, and institutional fit. Every new online post is treated as an observation that updates these calculated reputation metrics over time:
Here, $z_t$ represents the calculated reputation state at time $t$, $x_{1:t}$ is your chronological online trace stream, $G_t$ is your local trace graph, and $C$ represents the target audience evaluation filters. The state updates dynamically as new public evidence is added, adjusting weights based on trace quality.[5] Mathematical Note: These equations represent the formal framework we use to estimate observer updates; they are simplified here for the interface demonstration. Our active system uses hybrid text heuristics and local language model parsing to calculate changes.
Originality and institutional consistency operate as trade-off axes. Creative builders often publish high-variance, multi-domain proofs (like speculative research posts next to deep code repositories). Legacy screening filters penalize this as narrative volatility. Optic simulates how these nonstandard profiles register as high risk to standard recruiters, but high upside to frontier startup allocators. **Our Core Philosophy:** The goal is not to maximize all scores or sanitize your profile into standard corporate sameness. The goal is to align your online footprint with your target audience's needs without destroying your original ideas.
[Simulated Reputation Diagnostic] Your online footprint is fragmented. Your posts split into competing technical and non-technical domains without an explicit thread connecting them. Under standard corporate screening filters, this is flagged as focus instability.
[Simulated Reputation Diagnostic] High-quality technical contributions are present but fail standard credential checks. This signals extreme capability but low corporate legibility, making your profile a nonstandard professional signal.
Optic processes your public online profiles and uploaded files, grouping them into three distinct types:
• Public Trails: Public GitHub code repositories, personal websites, and public posts.
• Your Uploaded Profiles: Your exported LinkedIn data ZIP or resume files.
• Optional Private Accounts: Google Docs or email subject lines, which require explicit advanced-mode permission and can be reviewed before anything is saved.
The local parser normalizes these disparate streams into a structured, chronological ledger.[6]
| Data Class | Formats Ingested | Consent Boundary | Storage Location |
|---|---|---|---|
| Public Professional Surface | GitHub API logs, personal site crawls, public articles | User-entered public URLs (Default) | Local Temporary Cache |
| User-Authorized Archives | LinkedIn export zip, X archive zip, CV uploads | First-Party Consent Only | Local Encrypted Vault |
| Private Cloud Integrations | Google Docs, Calendar feeds, Gmail subject headers | Optional Advanced Mode (Disabled by default, strict OAuth scopes, local parsing, and local PII pre-redaction) | Ephemeral Sandboxed Memory |
| Regulated Sensitive Logs | Financial transactions, medical records, background dossiers | Prohibited (No-Go Charter) | Blocked at parser level |
The system compiles your digital timeline into a structured local trace graph $G_t$, showing exactly how your posts connect to your final reputation metrics.[3] The different nodes and relationships inside this graph are defined below:
| Node Types | Relational Edges | Description / Dynamic Contribution |
|---|---|---|
Artifact, Claim |
supports, contradicts |
Links your raw posts and commits to concrete claims and professional skills. |
Entity, Credential |
authored-by, verified-by |
Establishes where the post came from, its authority, and verified signatures. |
Risk, Audience |
outdated-by, context-for |
Models temporal decay[7], contextual overrides, and target audience rubrics. |
Optic links every high-level reputation warning directly back to the specific online post or code commit that caused it. This gives you **complete proof traceability**: you can click on any metric to see the exact posts, commits, or career timeline gaps that influenced the score, along with the estimated impact margin we calculated for each event.
Our Truthfulness Standard: To prevent subjective opinions from being presented as objective numbers, Optic operates on a strict transparency standard:
Click on any data point in the graph above to trace why it was flagged:
Verifying Technical Contributions: To prevent users from gaming the system by simply writing keywords on their resume, our local parser verifies code commits by checking the repository continuity, readme documentation, public stars, live deployed link anchors, and historic commit activity.
| Timestamp | Source Log | Typed Observation Claims ($x_t$) | Latent Contribution |
|---|---|---|---|
| 2026-03-12 | Twitter Thread | Speculative thread mapping algorithmic selfhood and neural states. | Negative under recruiter template (Medium confidence) |
| 2026-04-24 | GitHub Commit | Overhauled GPU-based two-pass ASCII renderer in pure WebGL. | Positive, high confidence (Technical execution proof) |
| 2026-05-01 | LinkedIn Edit | Removed primary corporate title; shifted public positioning to stealth R&D. | Negative under recruiter template (Legibility gap) |
Different audiences judge you using completely different rules. For example, startup investors look for fast shipping speeds, while corporate recruiters look for job stability and linear histories.[8] Optic lets you test your online footprint against specific audience filters (Seed VC, Corporate Recruiter, or University Admissions) to find where your profile triggers specific warnings before you apply.
Optic is strictly a tool for personal self-audit. To prevent abusive candidate tracking and social ranking databases, our technology operates under rigid ethical rules:
Here, $y_a$ represents the simulated perceived friction index for target audience $A$, projected from the calculated latent state vector $z_t$. The vector $W_a$ represents the audience-specific priority filters (e.g., higher weights on execution proof for VCs), and $b_a$ is the baseline conservatism offset. The output is a scenario projection, not a ground-truth decision prediction.[9] Our priority weights evolve through a clear three-stage validation plan:
Optic runs completely locally on your device inside your browser's sandboxed storage. Personal files, emails, or public logs are parsed client-side and never leave your custody. Optic does not maintain a central database or sell your data. Instead, you have complete control over your exports: you can selectively redact specific warning-triggering posts and generate signed reputation files to share directly with employers on your own terms.
| Component | Execution Location | Data Scope Ingested | Security / Failure Risk | Mitigation Primitive |
|---|---|---|---|---|
| Local Parser | Browser Sandbox (WASM) | Raw archives (X, GitHub, Resume) | Browser tab crashes due to huge files | Restricts processing limits and splits files into small, manageable chunks. |
| Local Vector Store | Browser Client (IndexedDB) | Chronological claim embeddings[11] | Unencrypted local data stolen from physical device | Encrypts local IndexedDB files using browser-level AES-GCM cryptography. |
| Local Engine | Sandboxed Web Worker | Inferred claims & weight maps | Malicious online text tricks the scoring system | Validates and strips all active code or script text prior to scoring. |
| Optional Cloud | Redacted Ephemeral API | Scrubbed, minimized claims (No personal info) | Network metadata or IP tracking | Scrubs names, emails, and phone numbers client-side before any transit. |
Every warning has an actionable fix. You can redact specific posts, clarify career timeline context, or link external verifiable proofs. Optic does not present ratings as unchangeable truths, but as simulated risks that you can easily edit or override.
Optic separates data levels inside your browser dashboard:
• Verifiable Fact: Verifiable facts about your footprint (e.g. 15 commits).
• Extracted Claim: Assertions parsed inside your posts (e.g. bioengineering skills).
• AI Recruiter Interpretation: Simulated recruiter scores based on ATS models.
• Friction Score: Simulated danger score showing the likelihood of rejection.
• Actionable Fix: Concrete steps you can take to resolve the warning.
While processing data client-side is highly secure, we also mitigate specific local risks:
• Malicious Browser Extensions: Third-party code attempting to read your screen.
• Local Device Theft: Physical access to browser databases.
• Prompt Injection: Malicious online text that tricks our AI models.
Our Mitigations: Optic enforces local AES-GCM IndexedDB encryption, restricts Web Worker runtimes, and validates every parsed text token client-side.
[Simulate footprint adjustments below • Goodhart's Law Warning][4] Click the checkboxes to see how taking real-world repair actions will change your calculated reputation metrics and reduce friction with different audiences. Important: Avoid over-sanitizing your blog or code history. The goal is to make your online story legible to employers without stripping away original ideas.
To ensure the fidelity of our audience perception maps, Optic utilizes a continuous four-tier validation model:
Monetization aligns strictly with user defense, completely removing any incentives to resell data:
Our values are structurally enforced through an strict operational firewall:
The Problem: A developer wants to transition from a corporate analyst role to a high-end graphics programmer. Their online presence contains scattered graphics code commits, blog posts about biology, and three different side-project names. Automated recruiting software flags this high signal variance as "unfocused with high flight risk," resulting in automatic application rejections.
The Fix: The developer runs Optic's browser scanner. The tool identifies that the blog posts are causing the focus flags, and notes there is no live demo of their graphics skill. The developer consolidates their blog essays under a single graphics research theme, hosts a live WebGL interactive demo, and links their verified GitHub profile.
The Outcome: The simulated ATS "flight risk" score drops to zero, and the developer successfully secures a graphics engineering role.
Optic v1 is built using standard, lightweight client-side web technologies that deploy in minutes:
• Execution Sandbox: Runs entirely inside your browser's isolated runtime.[10]
• Local Database: Saved inside your browser's local IndexedDB database.
• Local Search Index: Search is calculated client-side using Orama.
• File Importers: Text parsers for LinkedIn, X (Twitter), GitHub, and resume PDFs.
• Scoring Engine: Scrubs personal details on-device before utilizing ephemeral cloud LLM fallbacks.
Optic's first principle is not scoring people. It is making opaque inference inspectable, contestable, and repairable under user control. Every feature of this architecture flows from that commitment: local processing, evidence-backed claims, user-custodied reports, and a strict prohibition on third-party evaluation markets.
Private by default • First-party only • Evidence-backed • No public score