Automatic Topic: Every sentence classified before your 2nd prompt — expert context attached, ready for CoT-grade answers.
Deep Agent: It decomposes the task and plans before it acts — refine, search, verify, answer — multi-step reasoning in the open.
Harness Agent: Autonomous execution in an isolated sandbox — reading files, invoking tools, correcting course on a live log.
Real Deliverables: It finishes like a senior engineer — not a chat reply, but a publication-grade report ready for handoff.
Insight View: It flags what the document forgot — unstated assumptions, compliance risks, missing requirements — before they cost you.
Intent Search: Retrieval that reads engineering intent, not keywords — ranked evidence, source-anchored, ready to drop into chat.
Whitehole View: The knowledge graph as an orbital system — concepts cluster by weight and density, and each opens into its full lineage.
Solar Layout: From constellation to sentence — every selectable node opens its cluster, properties, and the exact source line it came from..
Axis Shift: One knowledge graph, many taxonomies — re-clustered by topic, category, lineage, or risk, with nothing lost in the turn.
Causal Graph: Cause and effect mapped sentence by sentence — trace any claim upstream to its origin, downstream to its ripple risk.
Ontology Editor: Free text becomes computable variables — every value typed, human-confirmed, and anchored to its page coordinates.
Export Engine: A pre-flight audit shows exactly what will change — then emits the variable tables, JSON maps, and the finished DOCX.
Ontology Registry: Grounded or still floating — every concept scored by centrality, every structural gap in the graph made visible.
Audio Briefing: Two synthesized hosts walk the checklist — script and voice synced line by line, the whole review hands-free.
One-Click Slides: The validated checklist becomes an executive deck — structured from the causal analysis, downloadable as .pptx.

Project Story

From Information Overload to Finished Work

Professionals rarely struggle because they cannot find information. They struggle because there is too much of it to process, validate, organize, and turn into a deliverable someone will sign.

TurnOnAGI was built around one question:

What if AI could move past answering questions and actually produce the work product?

TurnOnAGI is an AI-native platform for professionals and consultants. It turns large volumes of documents into focused work areas, validated knowledge, and finished deliverables through four stages:

Discover → Focus → Validate → Produce

1. Discover

The platform reads and indexes documents — contracts, specifications, quotations, standard forms — using hybrid retrieval (keyword + dense vectors, fused by reciprocal rank) rather than a single vector store. Extracted entities and their relations are written into a per-user knowledge graph that is also published as a browsable, version-controlled knowledge base.

2. Focus

The system organizes that graph into perspectives and ranks what deserves expert attention, collapsing a corpus into a short list of decision points. Sentence classification decides whose eyes each line needs, so the list each expert sees is already theirs.

3. Validate

Deep Agents investigate the organized knowledge: they decompose a question, retrieve supporting passages, check each claim against its source, and flag what they cannot ground.

Every judgment a human makes on top of that — confirm, reject, rename, split — is written to an append-only decision ledger. Nothing is silently overwritten.

4. Produce

Autonomous Agents turn validated knowledge into the actual deliverable. This is where most professional time disappears: filling the firm's own contracts, quotations, and standard forms, field by field.

TurnOnAGI's Variable Ontology Workbench does that. Document templates declare where values live; the ontology maps validated knowledge onto those places; the platform emits the finished file and reports exactly what it replaced, what it left alone, and what it refused to guess at. When two sources disagree about one value, it does not pick one — it reports the ambiguity.

Underneath: Knowledge Isolated Per User, Sharpening With Use

Beneath the four stages sits the actual engine. This is what separates TurnOnAGI from a document summarizer.

The engine has two distinct layers. One works on terms. The other works on sentences. They exist for different reasons, and it is worth keeping them apart:

The term layer decides what goes into the document. The sentence layer decides whose eyes read it.

First, knowledge is physically separated per user

A professional's asset is the documents they have handled and the judgments they made on top of them. Pooling that into shared storage would end the product before it began.

Every user gets their own database file. A single access module is the only path to user-scoped knowledge, and an invalid user identifier is rejected rather than sanitized. Collection is off by default, and turning it off later retracts what was collected across every surface it reached.

Layer 1 — Terms: a private ontology that grows

From the documents a user uploads and the conversations they hold, the platform extracts Terms and accumulates them as that user's memory. Terms are stored under seventeen types:

Quantity · Concept · Process · Tech · Document · Risk · Org · Person · Resource · Value · Event · Legal · Time · Location · Media · NaturalEntity · Emotion

Collecting them is not the interesting part. Merging them is. The same thing appears under a different name in every document. When the platform finds terms that look alike, it asks Gemini to judge whether they denote the same thing, and merges them when they do. Scattered wordings converge into one ontology that belongs to that user alone.

That ontology is the variable set. Once the variables stand up, producing a professional document stops being writing from a blank page and becomes filling positions with values. This is why the same agent can populate a different customer's form without per-customer prompt engineering.

Layer 2 — Sentences: whose eyes are reading?

Separately from terms, sentences are classified as sentences. The purpose here is not to supply a value. It is to change how the document is read.

The first axis is engineering discipline, and this is the one that matters most:

project management · electrical · instrumentation · civil · architectural · fire protection · environmental · HVAC · mechanical · piping · process

Given the same specification, the sentences an electrical engineer must read are not the sentences a piping engineer must read. On a real project that separation is done by hand, with a highlighter, across thousands of pages, every time. The platform decides it per sentence. That axis spans roughly eleven classes, and accuracy there is high.

The remaining axes cut the same sentence a different way. Beyond who owns it, the platform classifies what the sentence is about (topic), what kind of requirement it imposes, and what type of work it sets in motion — down to the specific sub-domain underneath each. Together they answer four questions about a single line of text: whose is it, what is it about, what does it demand, and what work does it start?

These finer cuts are carried by a classifier of roughly 500 classes, and its accuracy is low. We state that plainly. We keep it because a coarse signal is still decisive when sentences have to be put back together.

Along these axes, sentences are decomposed and recombined. Instead of reading a corpus end to end, a professional cuts it by their own discipline, by the topic they need at that moment, by the kind of obligation they are chasing, or by the work they are about to schedule. The same pile of documents opens in a different shape for each reader and each purpose.

Nothing that works is thrown away

The platform learns from its own operation, through three loops:

Prompts. When a chain-of-thought run extracts knowledge well, the prompt that produced it is saved and folded into periodic retraining. The classifiers learn from their own best runs — a student–teacher loop that ships only through an automatic quality gate, and rolls back when the gate fails.

Skills. When a Deep Agent investigation ends well, the method that worked is saved as a skill in a versioned library. The next agent starts from what the last one got right — and nothing is adopted until it beats the current champion.

Terms. Every conversation leaves terms behind. They flow into the user's private ontology, merge with what is already there, and widen the variable set the next document can draw from.

The schema is not frozen and the agents are not static: the system classifies, investigates, and drafts better the more it is used.

Isolated memory yields terms; terms merge into an ontology; the ontology becomes variables; variables become the document. Alongside it, sentences split by discipline and topic, and open in the shape each reader needs. And every good run — a prompt, a skill, a term — is kept, and feeds the next one.

Why We Built It

Generative AI made text cheap. Professional work was never about text. We did not want to replace the professional with a chatbot — we wanted to give them a workforce that does the heavy processing while they keep the judgment.

There is a second reason, and it matters more to us.

Access to professional services is limited by one economic fact: expert time is expensive and does not scale. A contract review, a technical assessment, a compliance report — each consumes hours of a specialist's attention, so firms ration these services toward clients who can absorb that cost. Everyone below that price point self-serves or goes without. The gap is not a shortage of expertise. It is a shortage of expert hours at a price most clients can pay.

If the hours per deliverable fall far enough, the price floor falls with them, and professional judgment reaches people who currently receive none. That is the outcome we are building toward — and it is why the product ships in six languages, not one.

What We Learned

The hard part of enterprise AI is not producing an impressive answer. It is producing a reliable path from unstructured information to something a professional will put their name on.

Three things we did not expect:

The expensive mistake is a confident wrong value, not a slow one. Most of our engineering went into knowing when not to ask the model — deterministic rules answer first, and the model is only paid for what rules genuinely cannot decide.
Silent success is the real failure mode. For a while our document generation reported success while emitting a file byte-identical to the input. Now every export reports what changed, and the count comes from the actual write path, not an estimate.
Consent has to be reversible in every direction. Turning knowledge collection off has to actually remove what was collected — across every surface it touched — or the switch is a lie.

Built During the Hackathon

The pre-existing platform handled documents, chat, search, and accounts.

During the hackathon we built the layer that makes it an AI-native business: the per-user isolated knowledge inheritance pipeline and its term merging, the sentence classification models and their retraining loop, the validation loop, the autonomous agent runtime with its versioned skill library, and the Variable Ontology Workbench that produces finished documents — all running against Gemini in production.

The project demonstrates AI moving from reading → reasoning → validating → producing business deliverables.

What TurnOnAGI Is Becoming

The next generation of AI applications will not be places where people ask AI questions. They will be systems where people assign AI work.

The remaining challenge is clear: making these workflows more autonomous without giving up the reliability professional work demands.

From information overload to validated knowledge. From knowledge to autonomous execution. From execution to finished work.

AI that runs the work, not just assists it.

**https://turnonagi.com/auth/test/login - ID tester1 / PW tester1agi