-
-
SignalOS — The AI Attention Control Plane
-
Product workflow: fragmented signals become one focused, human-controlled intervention queue.
-
Privacy model: browser-local media processing with only derived metrics sent to localhost.
-
Public architecture: local-first event processing, deterministic ranking, optional GPT-5.6 judgment, and audit evidence.
-
Initial Top Attention queue: three ranked interventions backed by evidence.
-
After explicit human confirmation, the corrected queue re-ranks unresolved issues and retains history.
SignalOS — The AI Attention Control Plane
Inspiration
AI coding agents can generate code quickly, but supervising several agents at once creates a new bottleneck: human attention.
A developer may simultaneously face an unverified completion, a repeated replay failure, a permission blocker, microphone clipping before a demo, or poor camera framing. These signals usually appear across separate terminals, logs, dashboards, and browser controls.
SignalOS was inspired by one question:
What if all these signals could be converted into one trustworthy queue showing the three interventions that need human attention now?
SignalOS is not another autonomous agent. It is a local-first attention control plane that ranks evidence, recommends a safe next step, and keeps the developer in control.
What it does
SignalOS combines AI-agent reliability signals, human approval checkpoints, and presentation-readiness signals into one unified Top Attention queue.
It can surface issues such as:
- unsupported or unverified agent completion;
- repeated replay failure;
- blocked browser permissions;
- microphone clipping or sustained silence;
- low camera brightness;
- missing, multiple, or poorly framed faces.
Each incident includes its source, severity, score, evidence, reason for urgency, and a recommended safe action.
SignalOS clearly distinguishes between:
- Live GPT-5.6 Terra
- Stored GPT-5.6 decision
- Deterministic fallback
- Real Codex wrapper evidence
- Live sensor
- Simulation
- Local Ollama analysis
- Resolved
No corrective command is executed automatically. The user reviews the issue, inspects the proposed correction, and explicitly confirms the intervention. The action and outcome are persisted, the corrected continuation is loaded, and remaining incidents are re-ranked while the resolved issue stays visible in history.
How we built it
The frontend uses React, TypeScript, Vite, native CSS, browser MediaDevices APIs, Web Audio, and MediaPipe Tasks Vision.
The browser computes presentation-readiness signals locally, including:
- brightness;
- microphone level;
- clipping;
- silence;
- face presence;
- framing.
Only derived numeric metrics are sent to the localhost backend. Raw camera frames and microphone audio are not stored or transmitted.
The backend uses Python 3.12, FastAPI, Pydantic, SQLite, JSONL evidence, and the official OpenAI SDK.
Incoming events pass through one canonical event schema. Deterministic detectors convert events into incidents, related evidence is aggregated, and one shared ranking pipeline produces the top three priorities.
SQLite stores events, rankings, reviewed actions, and corrective outcomes. JSONL exports provide replayable, redacted evidence.
How GPT-5.6 was used
GPT-5.6 Terra acts as a bounded judgment layer for selecting the most important three incidents from validated candidates.
Its structured output is checked for:
- valid candidate IDs;
- duplicate incidents;
- correct rank positions;
- missing incidents;
- expected ordering constraints.
If the response is invalid, delayed, or unavailable, SignalOS falls back to deterministic ranking.
A successful validated GPT-5.6 Terra call used:
- 353 input tokens;
- 359 output tokens;
- 712 total tokens;
- 12.944 seconds latency;
- approximately $0.006268 estimated cost.
The static judge demo uses stored evidence and never presents that result as a live API call.
How Codex contributed
Codex accelerated:
- architecture scaffolding;
- typed event models;
- replay fixtures;
- ranking and validation logic;
- FastAPI endpoints;
- React components;
- SQLite persistence;
- privacy-preserving sensors;
- tests, audits, and documentation.
A real Codex lifecycle event was captured through a controlled, ephemeral, read-only wrapper. SignalOS presents this honestly as redacted wrapper evidence, not continuous monitoring of the main Codex session.
Key product decisions remained human-controlled, including:
- keeping interventions non-autonomous;
- using deterministic ranking as the safety baseline;
- processing media locally;
- separating live, stored, fallback, and simulated evidence;
- prioritizing a backend-free static demo for judges.
Challenges
Making model output trustworthy
The first GPT ranking result did not fully satisfy the required order and metadata contract. We added strict Pydantic validation and semantic checks so model output is never accepted blindly.
Building a no-rebuild judge demo
The live system normally uses FastAPI, but judges need an immediate test path. We created a static replay mode requiring no backend, API key, Codex installation, Ollama server, camera, or microphone.
Preserving privacy
Camera and microphone features can easily become invasive. SignalOS derives only the minimum required metrics and does not perform identity recognition, face matching, emotion analysis, demographic inference, biometric profiling, or raw-media retention.
Permission-denied test events are always labelled Simulation.
Keeping the architecture simple
We deliberately avoided WebSockets, message brokers, cloud databases, and agent orchestration frameworks.
Instead, SignalOS uses:
- one canonical event model;
- one ranking pipeline;
- SQLite;
- JSONL;
- explicit refresh;
- deterministic rules before model calls.
What we learned
SignalOS reinforced several lessons:
- Deterministic fallbacks make AI systems more dependable.
- Human confirmation should be part of the architecture, not an afterthought.
- Replayable scenarios improve testing, debugging, and judging.
- Privacy improves when systems store only the minimum necessary data.
- Live, stored, simulated, local, and fallback results must be labelled truthfully.
- Codex is most effective as a collaborator guided by clear human product decisions.
What is next
Future versions could add native integrations with more agent runtimes, configurable policies, team audit views, real-time updates, broader platform validation, and desktop packaging.
The core principle will remain:
AI should help decide where attention is needed, while humans retain authority over what happens next.
Log in or sign up for Devpost to join the conversation.