AI Enterprise SolutionsGPT & Claude

LockNLearn

The Target User: Higher-education STEM institutions, university departments, and their enrolled students tackling complex math, physics, and engineering coursework. The Problem (Context Fragmentation): Today, STEM education suffers from severe tool fragmentation. A student’s problem-solving workflow is scattered across disconnected silos: a PDF viewer for the assigned textbook, a generic AI chatbot for explanations (which cannot "see" the textbook's specific diagrams or problem banks), a separate digital whiteboard like Miro for step-by-step derivations, and isolated apps for tracking formulas or progress. Because these tools do not communicate, the learning experience breaks down. General chatbots dump long text walls instead of providing visual, contextual, and interactive step-by-step guidance. Furthermore, from an enterprise perspective, universities pay for these disjointed tools but lose all visibility into student learning analytics. Institutions cannot track where cohorts actually struggle, because the real problem-solving process happens across five unmonitored, disconnected tabs that vanish the moment the browser is closed.

Open the demo Video GitHub

Preliminary score

61.5/ 100Promisingaverage of 2 judges

Value for the user16.0 / 25
A specific problem and a clear outcome from solving it.
Prototype and use of AI20.0 / 30
A working core scenario, and what AI actually contributes to the result.
Quality testing10.5 / 20
Tests, examples of failures, and comparison with the current approach.
Feasibility9.0 / 15
Data requirements, running costs and a clear next step.
Originality6.0 / 10
A meaningful difference from common solutions.

What the judges wrote

Claude Opus 5.5Preliminary58/100
Strengths
Your screenshots show a real integrated workspace: a textbook problem with its figure, LaTeX step-by-step solutions on a tldraw board, a chat panel driving the board, and a per-chapter task tracker. That is more than a chat wrapper. Your agent architecture is concrete and sensible: a router, document/OCR, Python math sandbox, web and composer workers. Your testing write-up names specific failure modes, such as the tutor leaking final answers under frustrated prompts, OCR confusing ∂ with δ and cascading into wrong calculations, and malformed LaTeX or coordinates glitching the canvas. These are credible and useful findings.
To improve
You submitted to the Enterprise track, but your user value and business model are aimed at individual students. Your $4.99/$9.99 plans don't match the university-analytics pitch, and you name no adoption metric such as time per problem set or error rate versus the current workflow. Turn your failure observations into a small systematic benchmark, for example N textbook problems with answer accuracy, OCR symbol error rate and Socratic answer-leak rate, compared against plain ChatGPT. Back the 70–80% margin claim with actual per-request model costs. Also reconcile the Socratic mode: the deck lists it as a roadmap item and the chat screenshot shows 'no withholding' mode, while your write-up describes it as built.
GPT-6 AstraPreliminary65/100
Strengths
Your screenshots show textbook physics questions, diagrams, worked derivations, and progress tracking in one workspace, making the fragmentation problem concrete. Your router/document/math/composer architecture gives AI a meaningful role beyond chat. Your discussion of premature answer leakage, OCR symbol confusion, and malformed canvas updates identifies specific engineering failure modes rather than claiming everything works.
To improve
Your enterprise case needs a demonstrated institutional workflow, cohort-level output, and measurable adoption outcome—not only student-facing features. Show one reproducible upload-to-board tutoring session, distinguishing current Socratic functionality from the full engine on your roadmap. Turn your reported failures into a fixed test set with expected results, pass rates, and comparisons against a PDF viewer plus a general chatbot. Substantiate your margins with measured model, storage, and hosting costs—including heavy unlimited-text users—and define document retention and access controls for a focused university pilot.

The team

Muhamməd Teymurlu
developer
Toğrul MəmmədliLead
product
Əziz Əlizadə
developer

Disclosure

Required by the rules. Judges verify it against the repository.

Models: DeepSeek-Chat (primary routing and text/logic generation), Gemini 3.5-Flash (multi-modal vision, complex math OCR, and fallback), and FastEmbed paraphrase-multilingual-MiniLM-L12-v2 (for local embeddings).
Data: User-uploaded academic PDFs, scanned STEM problem images, and dynamic vector embeddings stored in Supabase pgvector. No proprietary pre-trained datasets were used; data is processed in real-time via RAG.
Components: LangGraph, FastAPI, Next.js (App Router), React, Supabase (Auth/Postgres), tldraw (for interactive whiteboard), PyMuPDF, and RapidOCR
Built during the event: Confirmed

Quality testing

We extensively tested the core Socratic tutoring mode against complex university-level calculus and physics problems. Today, tools like standard ChatGPT or Photomath simply dump the final solution immediately, completely stripping away the pedagogical value of struggling through a problem. To solve this, we built a LangGraph state machine to force the AI to withhold the final answer and guide the student step-by-step using a hidden dependency tree. However, during testing, this broke in fascinating ways. If a student wrote an overly demanding or frustrated prompt, the underlying text router sometimes broke its pedagogical character and leaked the final formula prematurely. We discovered that maintaining a strict teaching persona and preventing prompt-injection-style demands requires much more aggressive state validation and prompt clamping than we initially anticipated. Beyond the conversational logic, we stress-tested the multi-modal OCR pipeline and the interactive whiteboard synchronization. We found that while Gemini 3.5-Flash is exceptionally fast at reading standard textbook PDFs, it occasionally hallucinates complex mathematical symbols on handwritten or low-resolution scanned notes, such as confusing a partial derivative symbol with a standard delta. This misread cascades into the math worker, leading to incorrect calculations. Furthermore, we tested streaming live JSON operations from the backend directly to the Next.js tldraw canvas. When the math worker occasionally generated malformed LaTeX strings or out-of-bounds coordinates for geometric diagrams, our frontend parser would briefly choke, causing the whiteboard to glitch or drop a node before catching up. These honest failures highlighted the immense difficulty of orchestrating deterministic UI elements directly from probabilistic LLM outputs, though our fallback mechanisms eventually stabilize the session.

Worth 20 of the 100 points.

Running it

To run LockNLearn locally: 1. Prerequisites: Python 3.10+ and Node.js 18+. 2. Backend Setup: - Clone the repo: git clone https://github.com/Toghrul0303/LockNLearn.git - Install dependencies: pip install -r requirements.txt - Set environment variables (.env): DEEPSEEK_API_KEY=<your_key> GOOGLE_API_KEY=<your_key> TAVILY_API_KEY=<your_key> SUPABASE_URL=<your_url> SUPABASE_ANON_KEY=<your_key> - Start FastAPI server: uvicorn main:app --reload --port 8000 3. Frontend Setup: - Navigate to directory: cd v0_frontend_4 - Install dependencies: npm install - Set environment variables (.env.local): NEXT_PUBLIC_SUPABASE_URL=<your_url> NEXT_PUBLIC_SUPABASE_ANON_KEY=<your_key> NEXT_PUBLIC_API_BASE_URL=http://localhost:8000 - Start Next.js app: npm run dev 4. Note: If the backend service is spin-down on initial load due to cold-starts, allow ~30 seconds for the FastEmbed local embedding weights to initialize.

Project ownership

The team keeps the rights to this project. Judges were given access for verification only.