Inspiration

Wildfires are a problem where information can be both time-sensitive and fragmented. A satellite might detect an unusual heat signature, a local resident might photograph smoke, and weather data might indicate conditions favourable to fire spread. However, none of these signals alone necessarily proves that a wildfire is occurring.

The challenge is not simply collecting information. It is understanding how different pieces of evidence relate to one another, how reliable they are, and what happens when the systems responsible for analysing them cannot communicate.

This made wildfire investigation an especially interesting application for Neptune North's "Actors Work Better Together" challenge.

The challenge asks us to explore how multiple independent systems can collaborate towards a common objective, continue making decisions when communications are interrupted, and recover when connectivity returns.

Traditional approaches often depend on a central system collecting information before making a decision. We wanted to investigate a different possibility: what if each system could independently examine the evidence available to it, make progress locally, and collaborate with other systems whenever communication was possible?

That idea became EmberGap.

Rather than trying to create another wildfire prediction model, we wanted to build a platform demonstrating how distributed intelligence could support wildfire investigations, even when information arrives late, sources disagree, or communication links fail.

Our objective was to make the cooperation between independent systems visible and understandable, not just produce a final result.

What it does

EmberGap is a collaborative wildfire-evidence investigation platform powered by independent AI and data-processing agents.

It combines several sources of information to investigate potential wildfire incidents and produce explainable recommendations for human review.

The system uses five specialised agent roles:

1. Satellite Agent

The satellite agent processes thermal anomaly observations using NASA's Fire Information for Resource Management System (FIRMS).

It examines whether heat signatures are geographically and temporally relevant to a reported incident.

Crucially, a thermal anomaly is not automatically classified as a wildfire. The agent preserves information about the observation, its source and the limitations of interpreting it.

2. Weather Agent

The weather agent examines meteorological conditions using Open-Meteo, including temperature, humidity, wind and precipitation.

It also incorporates contextual information from NASA EONET, which provides metadata about recorded natural events.

Weather information helps establish environmental context, but the agent does not treat favourable fire conditions as proof of an active fire.

3. Witness Agent

The witness agent evaluates reports submitted by people who may have observed smoke, flames or other relevant conditions.

It considers the consistency of submitted information and identifies potentially repeated reports.

This prevents multiple submissions from the same source being automatically treated as independent corroboration.

4. Vision Agent

The vision agent uses image-analysis capabilities to assess uploaded photographs when the live model is configured.

It can identify visual characteristics consistent with smoke or other relevant features while recognising that similar appearances may have alternative explanations.

The system explicitly distinguishes visual interpretation from verification. A photograph alone cannot reliably establish where or when it was taken or whether it is authentic.

5. Fusion Agent

The fusion agent combines findings received from the other agents.

Rather than simply counting positive signals, it considers whether evidence is genuinely independent, whether findings conflict, which sources are unavailable, and what uncertainty remains.

Its output is an explainable recommendation about whether an investigation warrants human review, not a definitive declaration that a wildfire exists.

The investigation dashboard

EmberGap presents these findings through an interactive geospatial interface.

Our demonstration is centred on Italy, with a map that allows users to explore potential incidents, inspect thermal observations and open detailed investigations.

Each investigation can display individual agent findings, source information, evidence limitations, activity history and the resulting review recommendation.

The platform also includes eyewitness reporting and authentication functionality.

An important part of the experience is transparency: users can understand not only the recommendation, but also which agents contributed to it and what evidence they had available.

For the hackathon, we also created deterministic demonstration scenarios to explore different outcomes, such as corroborating observations, misleading visual evidence, missing satellite coverage, duplicated eyewitness reports and unavailable weather information.

These scenarios use simulated evidence rather than representing verified real-world wildfire incidents.

How we built it

We built EmberGap using a combination of web technologies, geospatial data integrations, agent-based processing and distributed-systems simulation.

Frontend and application architecture

The application is built with Next.js, React and TypeScript, using Tailwind CSS and reusable UI components.

We designed the interface around an evidence-first workflow.

Users can navigate from a geographic overview into individual investigations, examine the evidence collected by different agents and understand how the system reached its recommendation.

Our map interface supports geographic navigation, thermal anomaly visualisation and investigation markers, with Italy as the default demonstration region.

We wanted a system that makes complex distributed behaviour accessible to someone who is not necessarily familiar with distributed computing.

Backend and data persistence

We use Supabase for authentication, PostgreSQL storage, row-level security and private media storage.

Submitted reports, observations, agent findings, investigation statuses and activity events are represented through shared, validated data contracts.

These contracts ensure that different components agree on the structure of evidence and that findings retain important metadata, such as timestamps, source attribution and limitations.

Vercel hosts our Next.js application and server-side API routes.

We deliberately designed our processing around short-lived serverless execution rather than depending on permanently running infrastructure.

External evidence sources

We integrated adapters for three important data sources:

  • NASA FIRMS: Satellite thermal anomaly information.
  • Open-Meteo: Modelled and forecast meteorological information.
  • NASA EONET: Contextual metadata about recorded natural events.

The adapters normalise external information into a consistent representation that the agents can process.

They also account for unavailable responses, incomplete observations and source-specific limitations.

This is important because a missing response is not the same thing as a negative finding.

Independent agent runtime

The most technically interesting part of EmberGap is its agent runtime.

Each agent has its own logical state, task queue and view of the evidence.

Instead of every agent accessing one shared collection of information and immediately reaching an identical conclusion, agents receive information through simulated communication links.

They exchange events and update their local knowledge as new information arrives.

The runtime includes mechanisms for message delivery, duplicate handling, event histories and reconciliation.

We also implemented a decentralised fusion demonstration in which nodes can independently evaluate the evidence they currently possess.

This means that different nodes can temporarily reach different recommendations because they have received different subsets of the available information.

Agreement emerges through evidence exchange rather than by requiring one central authority to make every decision.

Network partitions and recovery

To address Neptune North's challenge directly, we built a deterministic network-partition demonstration.

The demonstration progresses through five stages:

  1. Connected: Agents exchange evidence and make progress towards the shared investigation goal.
  2. Partitioned: Communication links between groups of agents are interrupted.
  3. Working in isolation: Agents continue processing information available locally, even though they cannot access everything known elsewhere.
  4. Reconnected: Communication links are restored, allowing missing information to be exchanged.
  5. Reconciled: Agents update their local evidence histories and can reach a consistent view of the shared investigation.

The runtime handles duplicate deliveries and uses reconciliation mechanisms to exchange missing events.

This matters because reconnecting a distributed system is not as simple as sending every message again. The system must also avoid treating repeated information as new evidence.

Our interactive network visualisation lets users inspect how agent knowledge changes at different stages.

The current hackathon demonstration uses logically independent agents within a deterministic, single-process network simulation. It demonstrates distributed decision-making and recovery behaviour without claiming that the agents are running on separate physical machines.

Testing and reliability

We used Vitest for automated unit testing, Playwright for browser-level checks, and GitHub Actions for continuous integration.

Testing focused on more than whether an endpoint returned a successful response.

We also examined behaviour under communication failures, duplicated messages, unavailable external sources, conflicting evidence and attempts to combine synthetic and live information incorrectly.

An important requirement was that the application should still provide a reliable demonstration without depending on the availability of every external API.

Challenges we ran into

1. Making agents genuinely independent

Our first major challenge was designing agents that could make decisions independently instead of simply executing separate functions controlled by one central decision-maker.

It would have been straightforward to gather all information in one place and evaluate it using a single algorithm.

However, that would not meaningfully address the distributed-systems problem presented by Neptune North.

We needed agents to maintain their own state, process their own tasks and make progress based on the information they actually possessed.

This required careful separation between each agent's responsibilities, local evidence and communication mechanisms.

2. Handling interrupted communication

When communication fails, different parts of a distributed system can have different understandings of the same situation.

For example, the satellite agent might receive a new thermal anomaly while another agent is isolated and still working with earlier evidence.

We needed the system to continue operating without pretending that every agent had access to the latest information.

We also needed a reliable way to reconcile these different views when communication returned.

Our solution involved event-based communication, stable event identifiers, local histories and duplicate-aware reconciliation.

This allowed us to demonstrate partial progress during isolation followed by eventual convergence after reconnection.

3. Distinguishing missing evidence from contradictory evidence

This was one of the most important conceptual challenges.

If NASA FIRMS returns no matching thermal anomaly, that does not necessarily mean there is no wildfire. The relevant satellite might not have observed the location recently enough.

Similarly, a weather API timeout tells us nothing about whether a fire is occurring.

Early in development, we had to be particularly careful about how external source states affected evidence fusion.

We addressed this by explicitly representing missing, stale and unavailable information as evidence gaps.

That distinction allows the system to communicate uncertainty instead of producing misleading confidence.

4. Preventing evidence from being counted more than once

Multiple reports do not necessarily represent multiple independent witnesses.

Likewise, duplicated network messages should not strengthen an investigation merely because the same evidence has arrived repeatedly.

We therefore incorporated duplicate handling into both the witness assessment and distributed runtime.

Evidence needs to be evaluated according to its actual origin and relevance, not simply how many times it appears.

5. Integrating several independently developed systems

Our team worked in parallel on the frontend, database, external APIs, image validation and agent runtime.

While this accelerated development, it also created integration challenges.

Different components needed to agree on schemas, function interfaces, evidence formats and ownership boundaries.

We relied on shared TypeScript contracts, feature branches, automated tests and frequent integration to bring the pieces together.

The tight hackathon deadline made it especially important to prioritise a functioning end-to-end experience over unnecessary architectural complexity.

6. Making distributed systems understandable

An event log full of message identifiers and state transitions is useful for developers, but not particularly compelling for someone seeing the project for the first time.

We wanted the network behaviour to be visible.

The challenge was transforming concepts such as partitions, local evidence histories and eventual consistency into an interface where users could understand what was happening.

Our network view lets users step through communication failure and recovery, inspect changing agent states and see how local decisions evolve.

This became one of the defining features of the project.

Accomplishments that we're proud of

Our biggest accomplishment is turning an abstract distributed-systems challenge into a tangible application with a clear real-world motivation.

We are particularly proud of:

  • Independent agent reasoning: Different specialised agents evaluate evidence within their own responsibilities.
  • Progress during communication failures: Agents can continue useful work using locally available information.
  • Evidence reconciliation: After reconnecting, agents exchange missing information, handle duplicates and converge on shared evidence histories.
  • Decentralised decision-making: Our demonstration shows how different nodes can form local recommendations before eventually agreeing on the evidence available.
  • Explainable conclusions: Recommendations are connected to supporting findings, uncertainties and missing information rather than being presented as unexplained scores.
  • End-to-end integration: We brought together geospatial visualisation, external data adapters, user reporting, authentication, persistent investigation records and the agent runtime.
  • A visual demonstration: The network interface makes otherwise invisible distributed-systems behaviour understandable to judges.

We are also proud that the project acknowledges the limits of automated evidence assessment.

EmberGap is designed to support human investigation, not replace emergency responders or make unsupported claims about confirmed incidents.

What we learned

The most important lesson was that collaboration does not require every participant to know everything at all times.

In a distributed system, different actors can make useful progress using partial information.

What matters is designing their responsibilities, communication and reconciliation mechanisms so their individual contributions eventually support the same overall objective.

We also learned that resilience involves much more than keeping an application online.

A resilient system needs to handle delayed information, unavailable sources, repeated messages and disagreements without losing track of what is known and what remains uncertain.

Building EmberGap reinforced the importance of distinguishing data collection from evidence interpretation.

Satellite observations, weather conditions and eyewitness reports have different meanings and different limitations. Treating them as interchangeable inputs can produce misleading results.

Finally, we learned how important clear interfaces and shared contracts are when building a complex product collaboratively under extreme time constraints.

Our team developed several interconnected components in parallel, and maintaining compatible interfaces was essential to getting them working together.

What's next for EmberGap?

Our hackathon prototype demonstrates the underlying approach, but there are several directions in which we would like to develop it further.

1. Deploying agents across genuinely independent environments

Our current network-partition demonstration runs within one process.

A natural next step would be to deploy agents across different services, devices or edge environments, introducing real network interruptions rather than simulated ones.

That would let us evaluate how the architecture behaves under genuine infrastructure failures.

2. More advanced evidence fusion

We would like to improve how the system handles uncertainty, conflicting evidence, temporal relevance and varying data quality.

This would include more rigorous evaluation against representative datasets before making any claims about detection performance.

3. Broader geospatial intelligence

We would like to explore additional environmental and Earth observation sources, provided their provenance and limitations can be evaluated appropriately.

This could improve the context available to investigators.

4. Stronger offline and field capabilities

A future version could investigate whether agents running on field devices or edge hardware can continue useful processing when internet connectivity is limited.

This is particularly interesting for remote environments where reliable communication cannot be assumed.

5. Human-in-the-loop review

We want to develop the reviewer workflow further, allowing authorised users to examine evidence, record decisions and provide feedback on investigation quality.

Final thoughts

EmberGap started with a simple question:

What happens when multiple intelligent systems need to solve the same problem, but cannot always communicate?

We explored that question through wildfire investigation, where information can arrive from many independent sources and uncertainty matters.

By giving specialised agents their own responsibilities, allowing them to work with incomplete information, and enabling them to reconcile evidence after communication is restored, we built a prototype that demonstrates the value of distributed cooperation.

For us, the most important outcome is not that one agent can identify something interesting.

It is that multiple independent agents can collectively produce a more complete understanding than any one of them possesses alone, even when the network connecting them is unreliable.

That is the idea behind EmberGap, and what makes it our response to Neptune North's challenge.

Built With

Share this project:

Updates

Submission history