You can find the demo video over at https://sot.aaryanparveen.com/video
Inspiration
most big decisions get one meeting and a gut call. we wanted a way to change that. when making decisions that affect others, all parties must be considered and addressed. most importantly, the trail is not always kept, so it is always hard to track the chain of responsibility and origins of any idea.
What it does
school of thought (SoT) is a tool that we developed to simplify and streamline inclusive decision making that leaves everyone happy. since we are students, we do not have access to the funding other ai labs have. so, we optimised SoT for cost efficiency without losing out on the results.
you describe what you want to decide or predict in a sentence. school of thought asks the few questions that matter, so that it fully understands you questions. then, researches the topic with sources it can quote. to simulate the deliberation between parties, SoT writes a brief, and casts eight to twelve roles. each agent gets a position, red lines and the one thing that would change its mind. every decision is recorded with the agent’s stated reasons and tagged by an observer model for stance and assumptions. To track this state, it is closed into one merkle block per round. this way, the report says where the cast started, how it moved, who held, which arguments carried and what would change the outcome. hence any generated record (and potential errors) can be verified against the finalized transaction on solana.
How we built it
when we use any frontier llm, it usually thinks for a couple minutes (or hours if you're nerdy enough) and it gives you its output. however, the thinking trace itself, which the model used to arrive to that conclusion is just not tractable, so modifying this output in the future is like dealing with a black box when you don't know where something in your code came from. hence we came up with SoT. combining complex decision making capabilities of swarms.
we decided to use a flask backend and a vue 3 frontend, since it is easy to get around. we started with the idea of adding a form of git tracking to llm CoT and connecting them like obsidian graphs.
since we wanted to rely on actual data and research, we opted to search any existing solutions online, where we stumbled upon the research by Shekar, S and Krishnan, 2026 which we decided to expand on using swarms of agents in SoT.
this paper outlined a way how CoT can be managed in a structured way. while searching for ways to integrate this idea, three things influenced our decision. first, we needed a way to prove that a transaction (or in this case, generated text or thought about a problem) has been made by an agent, . this way, the decision can be supported by a fact rather than a heuristic. second, we need to have the surety that the history has not been altered in any way; be it the people using the tool or the agents correcting previous errors).
every model call goes through one gateway, so the landing-page switch picks the provider for every role at once: gemini flash lite and openrouter free models, and a local qwen we used for the initial testing (yes on my laptop, the one i'm typing this on in the maths building). a separate experiment compares what agents say in their chain of thought with a linear probe on their activations.
Challenges we ran into
the agents agreed with each other within a few rounds. we gave each one an anchored position and a turn card that repeats it and flags drift, and refused repeats and self-likes, with the refusal on chain. the observer model scored every hedged decision 0.0 until we told it to use the whole range. generated time plans meant 168 hourly rounds, most of them empty, so we capped runs and skip hours with no one awake. seed posts were logged twice. duckduckgo answered repeated searches with a bot check. the responses endpoint silently refused json mode until the word json appeared in the input, so our “better” profile ran on the fallback without saying so. the report argued for a conclusion it picked first, so we rewrote it to compute from the records.
Accomplishments that we're proud of
a full run from one sentence to a verifiable report. a chain inspector where you can open any round, record or transaction and recompute the proof in the browser. a report that no longer tells a story: start, movement, holders, movers and triggers all come from the data. a demo page that walks through a whole run on “is 4 a good private key?” and a reasoning check showing that most answers could be read from the model’s activations before it reasoned, while almost none of the changed answers admitted the hint.
What we learned
records beat memory. the gitofthoughts paper’s numbers matched what we saw: storing reasoning did not make models smarter, but it made their history checkable, diffable and mergeable. small models need explicit contracts for everything, from json shapes to “disagreement is allowed”. and most of the work in a multi-agent product is stopping the agents from being polite.
What's next for school of thought
receipts saved at anchoring time, so verify works after the validator prunes old slots. reruns that add nodes and facts to the same chain instead of starting over. merging two runs the way git merges branches, with conflicts surfaced instead of averaged. and more worlds than a plaza and a forum.
Log in or sign up for Devpost to join the conversation.