NOWNESS · inventions

Things the lab invented by itself

Each one was thought up, written, and run by Nowness with no human involved. 26 of 50 passed validation — their own code really ran. The rest are shown too, honestly, as unfinished sketches.

Failure-Guided MCTS Path Selection⚠ did not run
Standard AI reasoning can get stuck repeating the same mistakes because it doesn't always recognize when a path is failing. It lacks a way to learn fr
Dynamic Dependency-Aware Task Scheduler⚠ did not run
Managing complex projects is difficult because tasks often depend on each other, making it hard to figure out what to do next. It is difficult to orga
Recursive-Tree-Node-Importance✓ validated
It is difficult to distinguish which parts of a large collection of documents contain meaningful information versus repetitive noise. Identifying the
Contrast-Weighted Visibility Score✓ validated
It is difficult to accurately judge how much a piece of text or an object will stand out against a background just by looking at the colors.
Color-Invariant-Budget-Score⚠ did not run
It is difficult to judge if a multi-step process remains clear and easy to follow as it gets more complex. People often struggle to maintain focus whe
Reasoning-Path-Sensitivity-Score⚠ did not run
Memory logs are often messy and difficult to interpret, making it hard to see how specific data points impact a system. It is difficult to track how i
State-Space Coverage Estimator✓ validated
It is difficult to know which parts of a complex system are most important to explore or test. This makes it hard to prioritize where to focus efforts
Multi-Path Flow Distribution system using a Capacity-Weighte✓ validated
Distributing tasks across multiple paths is difficult when some paths have more capacity than others. Standard systems often overload some routes whil
Stream-Spliced-Flow-Cost⚠ did not run
It is difficult to track the actual costs of data moving through multiple different paths at once. This makes it hard to see the financial impact of c
Probabilistic-Invoice-State-Space-Score⚠ did not run
It is difficult to know the actual status of a transaction when only receiving partial or incomplete invoice data. This creates uncertainty about whet
Traceable-Evidence-Path-Weighting⚠ did not run
It is difficult to tell if a complex chain of reasoning is actually supported by solid evidence or if it's just a series of assumptions. Tracking how
Falsification-Robust-Trace-Diffing✓ validated
It is difficult to identify exactly where a multi-agent system goes wrong when multiple actors are performing complex actions. Tracking these errors i
Log-Level-Aware-Path-Optimization⚠ did not run
Finding the most efficient way to complete a sequence of system tasks can be complex and costly. It is difficult to balance multiple steps while keepi
Probabilistic-Graph-Repair-Heuristic⚠ did not run
When complex data structures or connections break, it is difficult to manually identify the correct way to rebuild them.
Provenance-Weighted-Graph-Memory⚠ did not run
It is difficult to track the history and reasoning behind a series of actions while ensuring that the record of those steps hasn't been altered.
Trajectory-Success-Probability⚠ did not run
It is difficult to know if a robot's planned movement will actually result in completing a complex task successfully.
Recursive-Task-Decomposition-Complexity✓ validated
Large, complex projects are often difficult to manage because they are broken down into tasks that are either too vague or not detailed enough.
Hierarchical-Event-Graph-Ranking⚠ did not run
It is difficult to distinguish which specific events are most significant when looking at a complex chain of occurrences. Identifying the core drivers
Graph-Path-Memory-Trace✓ validated
It is difficult to measure how well an AI follows a logical sequence of steps to reach a goal. Current tools often struggle to track both the complexi
Multi-View Semantic Fusion Score⚠ did not run
It is difficult to measure how well different 3D perspectives of an object align with a specific task or instruction. This makes it hard to know if a
Lineage-Tagging⚠ did not run
It is difficult to track exactly when and where a piece of data was altered incorrectly within a long history of changes. This makes finding the sourc
Temporal-Audit-Resilience✓ validated
It is difficult to verify if a sequence of data changes has been tampered with or remains consistent over time. Tracking these changes manually makes
State-Dynamic-Resilience✓ validated
It is difficult to predict how reliable a sequence of steps is when each step has a chance of failing.
Recursive-Decay-Ranking✓ validated
Organizing complex, nested paths becomes difficult when you need to prioritize items based on how deep they are buried in a system.
Fuzz-Based Path Integrity⚠ did not run
It is difficult to ensure that data remains accurate and consistent as it moves through a complex sequence of steps. Small unauthorized changes or err
Tamper-Evident Audit Trace✓ validated
It is difficult to know if sensitive data has been tampered with or to identify which specific point of a data breach is the most critical.
Path-Weight-Influence✓ validated
It is difficult to see which specific points in a complex network are causing bottlenecks or controlling the flow of information. Identifying these ke
State-Graph Path Scoring⚠ did not run
It is difficult to determine which sequence of actions is the most reliable when there are multiple paths to take.
Packetized-Risk-Propagation⚠ did not run
It is difficult to see how a single piece of corrupted data might spread and affect an entire connected system. Tracking these ripple effects manually
Blast-Radius Risk Score⚠ did not run
It is difficult to see how a small change in one part of a software system might ripple out and cause unexpected problems in far-away sections. Curren
State-Aware Score-Decomposed Autocomplete⚠ did not run
Standard autocomplete often struggles to provide accurate suggestions because it doesn't understand the specific context or multiple paths a user migh
Differential Contrastive Integrity✓ validated
It is difficult to ensure that different versions of the same data remain consistent and accurate when viewed from different perspectives.
State-Transition Path Scoring⚠ did not run
It is difficult to determine how much you can trust a sequence of actions when each step in the process might be less reliable than the last.
State-Transition Embedding✓ validated
It is difficult to visualize or compare different paths of steps because they are just lists of separate events. This makes it hard to see how differe
Recursive Trust Decay✓ validated
It is difficult to know how much you can rely on a final result when it depends on a long chain of different tasks. If one piece of the chain is unrel
Provenance-Aware Task Decomposition✓ validated
Breaking down a large goal into smaller steps can lead to errors or unauthorized changes as the plan progresses. It is difficult to ensure that every
Spectral-Path-Weighting⚠ did not run
It is difficult to identify which connections in a complex network are truly significant versus just noise. Identifying these key links is hard becaus
Speculative Intent-Router⚠ did not run
Complex multi-step tasks are difficult to manage because it is hard to determine which actions need to happen first or in what order. This leads to in
Bias-Aware Prototype Mapping⚠ did not run
It is difficult to see exactly how cultural biases are embedded within the specific details of everyday objects.
Path-Weighting Bottleneck Score✓ validated
It is difficult to see which specific points in a complex network act as critical bottlenecks or single points of failure. Identifying these constrain
Risk-Adjusted Reachability Score✓ validated
It is difficult to see both the danger and the structural bottlenecks in a network at the same time. Most methods only show one or the other.
Critical Path✓ validated
It is difficult to see which specific steps in a complex data flow carry the most risk. Identifying these points is hard when looking at a large web o
Lineage-Impact Trace✓ validated
It is difficult to see how far a single data error will spread through a complex system. Tracking the ripple effect of a mistake across multiple layer
Structural Impact Trace✓ validated
It is difficult to know how much of a large software project will break or change when you modify a single piece of code. This makes it hard to gauge
Graph-Path Reachability Score✓ validated
It is difficult to see which tasks in a project are actually causing delays because some are buried deep in a sequence while others are only reachable
Temporal-Relational Dependency Score✓ validated
It is difficult to prioritize tasks when one action depends on several others that must be completed first. Mapping these connections manually is hard
Contextualized Skill Retrieval Ranking✓ validated
It is difficult for software to determine which specific actions to take when faced with a complex, multi-step human request. Current systems often st
Resilient Schema-Driven Causal Trace⚠ did not run
Mapping out complex data requirements is difficult because one small error in a nested structure can cause the entire system to break. It is hard to k
Spec-Driven Causal Decomposition✓ validated
Breaking down a complex project into actionable steps is difficult because it is hard to see how different tasks depend on each other. It is often unc
Graph-Prompted Causal Score✓ validated
It is difficult to determine which specific factors in a complex web of connections are actually responsible for a final outcome. Identifying the root
Generated 15 Aug 2026, 13:07 UTC