AI Enterprise SolutionsGPT & Claude

Bahar

Bahar is built for quality assurance (QA) teams, food safety specialists, and regulatory compliance managers at packaged-food manufacturers. These professionals must ensure that every product label accurately reflects its ingredients, allergens, supplier specifications, and manufacturing conditions before a product reaches consumers. Today, this information is scattered across spreadsheets, supplier documents, recipes, and packaging records. When ingredients change, suppliers substitute materials, or allergen information is incomplete, discrepancies can go unnoticed during manual reviews. The consequences are serious: undeclared allergens, incorrect labels, costly product recalls, regulatory penalties, and potential harm to consumers with food allergies. Bahar addresses this problem by connecting ingredient, supplier, formulation, and labeling evidence in one AI-assisted platform that detects potential discrepancies, explains findings, and supports traceable human review before product release.

Video GitHub

Preliminary score

69.0/ 100Promisingaverage of 2 judges

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

What the judges wrote

GPT-6 AstraPreliminary70/100
Strengths
Your packaged-food QA focus addresses a concrete, high-consequence workflow, illustrated by omitted sesame and ambiguous lecithin origin. Your separation of ingredient candidates, qualified evidence and human release authority makes the prototype meaningfully different from a simple allergen lookup. Your reported adversarial tests and documented fixes—including stale assessment results and authorization gaps—provide useful evidence beyond generic success claims.
To improve
Your next demonstration should run one complete document-to-review case against the live backend, clearly showing the lexical engine's contribution and which integrations remain unverified. Benchmark against professional reviewers on independently labeled supplier documents and packaging samples, measuring high-severity false negatives, abstentions and review time. Complete PostgreSQL tenant-isolation and live identity testing, and reconcile the historical 53-test report with the submitted 136-test result in a freeze-version report. Add per-assessment operating costs and a narrowly scoped customer pilot with a measurable adoption target.
Claude Opus 5.5Preliminary68/100
Strengths
Your problem framing is unusually precise: QA and compliance staff at packaged-food makers, with concrete failure points such as the E322/lecithin origin ambiguity and the recipe-says-sesame, label-omits-sesame case. Your four-valued evidence model (positive, negative, unknown, conflicted) and time-aware rule selection are thoughtful. Modelling Azerbaijan's 14-category list effective 1 January 2027 makes the tool locally relevant. Your testing write-up is honest and specific: 136 automated tests, skipped PostgreSQL tests disclosed, concrete bugs found and fixed, and a clear statement that accuracy against manual reviewers has not been measured.
To improve
The AI core is a deterministic vocabulary matcher, and the LLM path was not verified, so AI is not yet essential to the result. Show where a model measurably improves extraction or matching over the lexical baseline. Run your 56 synthetic cases, plus a handful of real labels, against a manual reviewer and report time saved and missed-allergen rate, since that is the adoption metric this track asks for. Add running-cost estimates (hosting, OCR, optional LLM calls per assessment). Reconcile the test counts between your deck (53) and your submission (136).

The team

Ahmad AbdullayevLead
developer
Yasin Quluzada
data

Disclosure

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

Models: ARKHE LabelGuard AI Core v0.4 — a deterministic, vocabulary-based ingredient recognition and candidate extraction engine. The platform also supports an optional OpenAI-compatible LLM integration (configured default: gpt-4.1-mini), but external model usage was not verified in the tested demonstration. No custom model training or fine-tuning is claimed. AI-generated suggestions require evidence validation before acceptance.
Data: Internally assembled ingredient knowledge dataset containing 160 ingredient concepts, 324 aliases, 15 categories, 137 semantic relations, and 56 synthetic evaluation cases. Includes three regulatory reference profiles and nine documented sources, including FDA, European Commission, FAO/WHO, and Codex materials. Synthetic test fixtures were used for validation. No private customer datasets or proprietary third-party training data were used or claimed.
Components: Python, JavaScript, HTML/CSS, PostgreSQL, SQLAlchemy, Alembic, Docker, PyJWT, cryptography, S3-compatible object storage, ClamAV, Tesseract OCR, and PyMuPDF. The project includes an existing ARKHE AI Core and earlier LabelGuard application design elements, alongside updated assessment, evidence-governance, authentication, authorization, and responsive frontend functionality. Open-source libraries and public technical documentation were used.
Built during the event: Confirmed

Quality testing

We tested Bahar's allergen assessment accuracy, ingredient recognition, evidence handling, authentication, authorization, data integrity, and responsive interface. Results: 136 automated tests passed, with 5 PostgreSQL integration tests skipped because the test database was not configured. Chromium frontend checks also passed at five screen widths (320–1440px). What we tested: - Allergen detection: Missing allergen declarations, ambiguous ingredients, conflicting supplier evidence, and incomplete formulations. - AI reliability: Uncertain ingredient matches, failed extraction, and attempts to promote unverified AI suggestions into confirmed facts. - Security: Invalid tokens, forged identities, unauthorized tenant access, privilege escalation, and missing MFA verification. - Data integrity: Concurrent changes, duplicate requests, immutable audit history, and unauthorized approval actions. - Usability: Mobile responsiveness, navigation, assessment results, error handling, and form validation. What broke and how we fixed it: - Earlier authorization boundaries were insufficiently strict. We added verified identity, server-side tenant membership checks, role-based permissions, and independent approval controls. - Failed assessments could leave previous results appearing current. We improved error reporting and historical-result separation. - Mobile navigation and dashboard metrics had inconsistencies. We corrected them and added responsive regression checks. - Partial document-processing failures produced ambiguous feedback. We added explicit partial-success and extraction-error states. Compared with today's manual process: Food-label verification often requires reviewing disconnected spreadsheets, supplier specifications, recipes, and packaging documents. Bahar centralizes evidence, automatically flags potential discrepancies, and makes uncertainty and review history visible. However, we have not yet measured time savings or accuracy improvements against professional manual reviewers. Remaining limitations: Live SSO integration, full PostgreSQL tenant-isolation testing, production-scale performance testing, independent food-safety validation, and real-world accuracy benchmarking remain incomplete. Bahar is a tested prototype, not a certified replacement for expert regulatory review.

Worth 20 of the 100 points.

Running it

Repository: https://github.com/ahmadabdullayew/Bahar Requirements: Python 3.11+, pip, and Git. No Docker, API key, or external credentials are required for the local demonstration. 1. Clone and install ```bash git clone https://github.com/ahmadabdullayew/Bahar.git cd Bahar python3 -m venv .venv source .venv/bin/activate python -m pip install -e '.[dev]' ``` 2. Launch the browser application ```bash bahar serve --host 127.0.0.1 --port 8088 ``` Open http://127.0.0.1:8088 3. Run the included assessment examples (in a second terminal with the virtual environment activated) ```bash bahar demo --case unsafe bahar demo --case ready ``` 4. Run automated tests ```bash python -m pytest -q ``` Credentials and seed data: No login or database seeding is required for the local SQLite demonstration. Bundled assessment examples are included. Known limitations:The local demonstration is not a production deployment. PostgreSQL-backed operations, document custody, and authenticated approval workflows require additional infrastructure. The Docker deployment requires externally configured OpenID Connect identity settings and related services. Deterministic ingredient extraction is not independently validated for real-world regulatory accuracy. The application does not certify food-label compliance or authorize product release. For production configuration and further limitations, consult the repository README and the documentation under `docs/`.

Project ownership

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