Knowledge Graph Creation

Synthesys — AI Agents for Process Efficiency

A cheeky little platform that turns factory data into measurable throughput, yield, and profit—without the black-box vibes.

Inspiration

This started on the factory floor. You learn to respect constraints, cycle times, and data—or the line teaches you the hard way. That rhythm kept pulling us back.

We wanted deep tech, not another wrapper. For this hackathon, our goal was simple: ship something valuable and hard to copy.

Manufacturing felt like home turf. Adoption of AI agents is still early, but the problems are concrete and the KPIs are real. YC’s prompt to reimagine its top startups with agents sent us scanning the portfolio—where Tractian stood out. Predictive maintenance is great for cutting loss, but we asked a louder question: what actually raises profit?

If a Tractian-like product were conceived today, it would start with process efficiency. So we did. We built agents that watch flow, recommend adjustments, and push plants toward higher throughput and yield. ROI that shows up on the line, not just the maintenance log.

What it does

Synthesys is a platform (not just “an agent”). It connects to your IoT/SCADA data and a machine knowledge graph, finds inefficiencies, researches proven fixes, simulates the changes, and hands you explainable recommendations with before/after graphs.

End-to-end flow

Ingest & Model
Hook up telemetry. Build/augment a Neo4j machine graph: components, flows, constraints, setpoints, nameplates.
Issue Finder Agent
Detects losses using stats + lightweight physics (for our pilot chiller): ΔT problems, throttling losses, off-design operation, COP drifts. Outputs ranked hypotheses with evidence.
Query Crafter Agent
Auto-generates sharp search queries/keywords from the hypothesis (e.g., “increase evaporator effectiveness at low load”).
Research Scout Agent
Pulls 10–15 relevant academic/industrial sources and best practices.
Selection & Synthesis Agent
Reads and scores each intervention (expected gain, feasibility, safety, constraints). Converts the best path into actionable changes (parameter tweaks, control logic hints, setpoint schedules).
Simulation Agent
Translates actions into a config for our physics sim (digital-twin-lite). Runs before/after to estimate impact on yield/throughput/COP/energy.
Comparator & Report Agent
Generates side-by-side graphs and explanations: what changed, why it helps, and what to monitor. No hand-wavy magic.

Pilot scope: a classic Evaporator → Compressor → Condenser chiller loop—common across plastics, food, pharma, and semiconductors. Just complex enough to matter, simple enough to ship in a weekend.

How we built it

Frontend
- React + Material UI, atomic design.
- xterm.js for an in-browser command terminal that streams agent output.
- We vibecoded it (with Claude Code + other code LLMs), then tightened it up. Atomic design let everything snap together like LEGO.
- UX in UX Pilot.
Orchestration
- FastAPI backend with SSE streaming.
- FastMCP servers to compose agents and stream their thinking/process to the terminal (transparently, not creepily).
Knowledge & Storage
- Neo4j for the machine knowledge graph.
- Amazon S3 for artifacts and graph assets.
- Time-series adapters (mocked/synthetic for the hackathon; real connectors next).
Physics & Simulation
- Thermodynamics-based models (heat exchanger effectiveness, simplified compressor maps, COP).
- Physics-grounded synthetic data generator to bootstrap when real telemetry is sparse.
- Comparator for clean before/after deltas.

Challenges we ran into

Choosing the machine. Motors were too simple; mills/presses/molders were too spicy for a weekend. Chiller hit the Goldilocks zone: ubiquitous, improvable, shippable.
Understanding the chiller. “Simple” still meant hours of ΔT, superheat/subcooling, COP, and where efficiency actually leaks out.
No dataset. We had a manual and a loop diagram—no telemetry. We built a knowledge graph and physics-grounded synthetic data to move forward.
Right-sizing research. The scout sometimes fetched 0 or 20+ papers. We added a budgeted retrieval policy (target 10–15), early-exit heuristics, and dedupe.
Tool governance in MCP. You can’t hard-limit per-agent tools easily. We added policy guards and per-agent timeouts to keep runs sane.
Context windows are not warehouses. We created a compact briefing index (summaries + key equations) with on-demand expansion.
Fidelity vs. speed. We used first-order models for realism without missing the demo. Assumptions are labeled, not hidden.

Accomplishments we’re proud of

Working knowledge-graph editor + runtime. Found an OSS prototype, wired S3 + Neo4j, upgraded the UI, and used it to author the chiller graph.
Physics-based synthetic data. Equations + realistic ranges/noise = data good enough to drive detection and simulation.
Full agent loop, end to end. Detection → literature-driven fixes → simulated impact → explainable report, all streamed in terminal UX.
Hacker joy. Shaurya coded happily for ~40 hours. Coffee was harmed in the making of this demo.

What we learned

Physics is hard. Thermodynamics is harder. Chillers are not cool.
We can now chant Evaporator → Compressor → Condenser better than “Happy Birthday.”
Suryansh: revived a dormant open-source platform; shipped UX Pilot, Neo4j, S3 integration.
Vishwa: built physics-grounded synthetic data and detailed docs (units, ranges, materials, theory).
Shaurya: agent orchestration, SSE streaming UX, and turning multi-agent chaos into crisp, explainable outputs.

What’s next

Live plant connectors: OPC UA / Modbus / MTConnect.
More equipment: cooling towers, pumps, ovens, mixers—generalize beyond chillers.
Human-in-the-loop: approval gates, guardbands, rollback plans for any recommended change.
Deeper sims: plug-in support for higher-fidelity digital twins when available.
ROI dashboard: translate kWh saved, yield gains, and throughput into dollars.
Governance: stricter tool budgets, audit logs, and per-agent capability caps.

Appendix — Agent Roster

Issue Finder Agent — detects inefficiencies using telemetry + physics against the knowledge graph; outputs ranked hypotheses and constraints.
Query Crafter Agent — turns hypotheses into high-signal search queries/keywords.
Research Scout Agent — gathers 10–15 relevant papers/best practices.
Selection & Synthesis Agent — reads/scores options (physics-aware) and converts the winner into actionable changes.
Simulation Agent — converts actions into a sim config and runs before/after.
Comparator & Report Agent — generates clean graphs and explainable summaries.