Inspiration
When I started building Taraxis, I was not looking for another system that simply returns a ready-made answer. I was interested in everything that happens before that answer appears: how new evidence changes the system’s understanding of the world and what the system should do when the evidence is incomplete or contradictory.
I want Taraxis to treat uncertainty honestly. Instead of hiding a gap behind confidence, the system should be able to show exactly where that gap is and turn it into a specific question.
Taraxis Cognitive Trace Sandbox turns one small part of this broader idea into a system that people can run, explore, and verify for themselves.
What it does
The sandbox lets you observe how synthetic observations move through a six-stage cognitive pipeline:
Observation → Signal → Interpretation → Phenomenon → World State → Curiosity
At every stage, you can see:
- what the system received;
- how the information was transformed;
- what result was produced;
- whether the available evidence was sufficient;
- the confidence level associated with the result;
- the provenance connecting the result to the original evidence;
- the reason for moving to the next stage.
The sandbox includes three synthetic scenarios:
- Missing knowledge — there is not enough evidence, so Curiosity emerges.
- Contradictory evidence — two sources report values that cannot be safely reconciled, so Curiosity formulates a question.
- Sufficient coherent state — the evidence is complete and consistent, so the pipeline finishes without Curiosity.
Judge Mode runs the most representative scenario from beginning to end. Two completed cognitive traces can also be viewed side by side their provenance can be explored and the full structured trace can be exported as JSON for repeatable verification and further analysis.
What I built during OpenAI Build Week
The larger private Taraxis project existed before OpenAI Build Week began. I am not presenting the complete private system as new work created during Build Week.
The competition submission is Taraxis Cognitive Trace Sandbox — a new, separate, and portable implementation created during the event to demonstrate one of the key principles behind Taraxis.
During Build Week, I created:
- a portable Python application that is independent of specific file-system paths;
- a deterministic synthetic scenario engine;
- a browser interface for exploring cognitive traces;
- stage-by-stage provenance visualization;
- Judge Mode;
- side-by-side cognitive trace comparison;
- structured JSON export;
- three safe synthetic scenarios;
- automated tests;
- cross-platform launch instructions and separate instructions for judges;
- a competition-safe public repository.
The private Taraxis architecture, production runtime internal records production data and private infrastructure are not included in this submission.
How I built it
I used Codex and GPT-5.6 in a separate development session dedicated to Build Week.
I defined the product behavior, architectural boundaries, public-disclosure limits, acceptance criteria, and the distinction between the private Taraxis system and the public sandbox. Codex helped implement the project structure deterministic pipeline browser interface, Judge Mode, comparison mode, JSON export, tests and documentation.
Throughout the process, I reviewed the implementation and tested the final system behavior against the expected outcomes for all three scenarios.
The application intentionally has a minimal technical footprint. At runtime, it uses only the Python standard library and does not require an API key external database cloud account credentials, production server, or network connection after download.
Challenges
The hardest part was deciding not only what needed to be built, but also what could not be disclosed.
I wanted the sandbox to demonstrate a real principle from Taraxis without publishing the private architecture or depending on the production environment. This boundary influenced the scenarios, the repository structure, the documentation, and even the way the system describes itself.
Another challenge was making an abstract cognitive process understandable on screen. The pipeline had to remain deterministic and technically inspectable while still allowing someone to understand the result within a few minutes.
Portability was also extremely important. The public version could not depend on private paths, credentials, databases, production services, or hidden infrastructure. A judge needed to be able to clone the repository, run one command, and see the same result.
Accomplishments
What I am most proud of is that the repository is not just a visual mock-up or a prop for the video. Judges can actually download it, run it locally, explore the cognitive traces, and verify the results.
The completed sandbox includes:
- a working six-stage deterministic pipeline;
- three scenarios with meaningfully different outcomes;
- inspectable provenance at every stage;
- a complete end-to-end Judge Mode;
- side-by-side cognitive trace comparison;
- valid structured JSON export;
- zero third-party runtime dependencies;
- launch instructions for Windows, Linux, and macOS;
- 18 passing automated tests;
- no production credentials, private data, or canonical Taraxis files.
What I learned
I realized that the ability to inspect how a system works cannot simply be added after it has already produced the final result. It has to be part of the process itself.
To understand a result, you need to see what each stage received, what it produced, why the transition happened, and which earlier evidence supports it.
I also realized that uncertainty does not necessarily have to be treated as a refusal or a system error. When evidence is missing or contradicts other evidence the safest outcome may be to preserve that uncertainty and turn it into a specific question instead of creating unjustified confidence.
What’s next
The first additions I would like to implement are user-created scenarios, richer cognitive trace visualizations, replayable histories, and stricter schema validation.
Future versions could also explore optional model-assisted analysis while preserving the deterministic cognitive trace and an inspectable provenance layer.
This sandbox is intentionally narrow in scope. It is not the complete Taraxis system and does not reproduce the private production architecture. It demonstrates one principle that has special meaning to me:
A system should not hide what it does not know. Uncertainty can be made visible, explainable, and verifiable.
Log in or sign up for Devpost to join the conversation.