Execution Journal #006
Perplexity Computer Executes Forge
An autonomous Perplexity Computer agent conducted an end-to-end computational research project through Forge's deterministic execution infrastructure. Without predefined datasets, workflows, or computational primitives, it independently designed a methodology, discovered public information, selected capabilities, executed more than 17.6 million probabilistic iterations, and produced replayable evidence supporting the resulting research report.
Executive Summary
Most AI systems are designed to produce answers.
This experiment examined what happens when an AI agent is allowed to continue beyond reasoning and into deterministic computation.
Perplexity Computer received a single research objective:
Investigate future global wildfire vulnerability under current environmental conditions using probabilistic computation.
No datasets were supplied.
No execution graph was predefined.
No mathematical primitives were selected in advance.
The agent was instructed to design the research methodology, discover and evaluate public data, construct the required datasets, identify suitable computational capabilities through Forge's native MCP interface, execute the workloads, verify the outputs, and produce an evidence-backed executive report.
The resulting workflow combined autonomous research planning with deterministic execution. It spanned data discovery, feature engineering, capability discovery, probabilistic simulation, graph propagation, ensemble aggregation, search, verification, and reporting.
Across the study, Perplexity Computer orchestrated 343 deterministic workloads totaling 17,645,075 probabilistic iterations across 75 countries and 24 metropolitan areas.
The wildfire assessment was the research application.
The autonomous computational workflow that produced it became the primary subject of the experiment.
Research Facts
| Property | Value |
|---|---|
| AI system | Perplexity Computer |
| Execution infrastructure | Forge Pool MCP |
| Research objective | Future global wildfire vulnerability |
| Capabilities inspected | 410 |
| Deterministic workloads | 343 |
| Probabilistic iterations | 17,645,075 |
| Countries analyzed | 75 |
| Metropolitan areas evaluated | 24 |
| Regional assessments | 7 |
| Primary computational families | Monte Carlo · Graph · Search · Ensemble |
| Evidence produced | Replay identities · Execution traces · Dataset hashes · Capability artifacts · Verification metadata · Machine-readable outputs |
The Experiment
Most interactions with AI systems begin with a prompt and end with a response.
The model reasons over available information, generates text, and the interaction concludes.
This experiment intentionally extended that boundary.
Instead of asking Perplexity Computer to explain a problem, we asked it to solve one through computation.
The objective was deliberately open-ended. The agent was not told which datasets to use, which probabilistic models to execute, or which capabilities existed inside Forge. Even the computational workflow remained undefined.
The only additional infrastructure made available to the agent was deterministic execution through Forge Pool's MCP interface.
Everything else had to be discovered.
The experiment therefore evaluated whether an autonomous reasoning system could independently progress through the major stages of a computational research project:
- Design a defensible methodology.
- Discover and evaluate public information.
- Construct a canonical research dataset.
- Identify the computational capabilities required for the task.
- Compose and execute deterministic workloads.
- Verify and preserve the resulting evidence.
- Produce a human-readable executive report.
The workflow was not predefined.
Designing the workflow became part of the problem the agent had to solve.
From Objective to Methodology
Before performing a single computation, Perplexity Computer translated the natural-language objective into a structured research methodology.
Rather than treating wildfire vulnerability as one undifferentiated score, the agent decomposed the problem into interacting components representing environmental hazard, fuel readiness, ignition potential, exposure, climatic variability, and uncertainty.
It then identified the public information required to represent those components.
The research process evaluated climate records, environmental indicators, socioeconomic data, geographic information, and lightning climatology. Candidate sources were not accepted automatically. Several were excluded because they introduced redundancy, duplicated variables already represented elsewhere, or risked leaking observed outcomes into a forward-looking probabilistic model.
That distinction matters.
The dataset was not assembled by collecting everything available. It was constructed through explicit research decisions about relevance, provenance, transformation, and exclusion.
The methodology itself became part of the evidence.
Constructing the Canonical Dataset
The selected information had to be converted into a computational form before it could be executed.
Perplexity Computer engineered the required variables, normalized incompatible inputs, preserved provenance for each transformation, and constructed a canonical dataset covering the selected countries and metropolitan areas.
The dataset was then bound to a cryptographic fingerprint.
This allowed downstream execution artifacts to reference a specific computational input rather than an ambiguous collection of source files. The hash connected the research methodology, the transformed dataset, and the resulting workloads through a stable identity.
That identity is essential for replay and audit.
A result is only reproducible when the system can establish not only which computation ran, but also which exact data representation entered it.
Discovering Computation
Traditional software executes algorithms selected before runtime.
This experiment followed a different pattern.
Forge did not expose a single perform wildfire analysis operation. It exposed a registry of deterministic computational capabilities from which the agent could construct its own execution strategy.
Through the MCP interface, Perplexity Computer queried the capability catalogue, inspected capability descriptions and schemas, and evaluated which primitives matched the methodology it had designed.
The agent inspected 410 available capabilities spanning probabilistic simulation, graph analytics, ensemble computation, search, optimization, and supporting execution operations.
From that catalogue, it selected the computational families required for the study:
- compound Monte Carlo simulation,
- drought-oriented probabilistic modeling,
- wind-oriented probabilistic modeling,
- metropolitan vulnerability analysis,
- ensemble aggregation,
- graph propagation,
- and deterministic search.
The execution infrastructure did not prescribe the research method.
It exposed computational building blocks.
The agent remained responsible for deciding which capabilities to use, how to parameterize them, in what order to execute them, and how to interpret the resulting outputs.
Planning remained the responsibility of intelligence.
Execution remained the responsibility of infrastructure.
Constructing the Execution Pipeline
Once the required capabilities had been identified, Perplexity Computer composed them into a coordinated execution workflow.
The resulting pipeline combined probabilistic simulation, graph propagation, ensemble aggregation, and search across multiple geographic and environmental dimensions.
Instead of issuing one opaque, monolithic computation, the agent decomposed the research into independently recorded workloads.
That decomposition made intermediate steps visible. Country-level simulations, metropolitan analyses, regional graph propagation, ensemble outputs, and search operations each produced their own execution identity and evidence.
The resulting execution graph reflected the computational decisions made during planning while preserving deterministic execution records for every completed workload.
This is a central property of the architecture.
The agent could adapt its strategy as the research progressed without sacrificing traceability at the execution layer.
Deterministic Execution
With the workflow established, Forge executed the workloads submitted by the agent.
The completed study consisted of 343 deterministic executions and 17,645,075 probabilistic iterations.
| Execution family | Workloads |
|---|---|
| Compound Monte Carlo | 75 |
| Drought Monte Carlo | 75 |
| Wind Monte Carlo | 75 |
| Metropolitan analysis | 24 |
| Ensemble aggregation | 75 |
| Graph propagation | 17 |
| Deterministic search | 2 |
| Total | 343 |
Each workload produced a persistent execution record containing the identifiers and metadata required to retrieve, inspect, and verify the completed work.
The computation therefore did not disappear after the report was written.
It became a collection of durable computational artifacts.
What the Research Produced
The purpose of this Journal is to examine the execution architecture, not to restate the full wildfire report. Still, the research outputs demonstrate that the workflow produced more than a generic risk ranking.
The study identified several distinct classes of vulnerability:
- locations with severe direct fire-weather hazard,
- regions where modeled vulnerability exceeded what visible exposure alone would suggest,
- infrastructure systems capable of propagating disruption beyond the initial hazard zone,
- and regimes where compound uncertainty produced heavier tails than baseline estimates implied.
These findings emerged through different computational families rather than a single scoring function. Monte Carlo workloads modeled uncertain environmental conditions. Ensemble operations combined independent signals. Graph propagation represented systemic transmission. Search surfaced configurations and tail regimes that warranted additional attention.
The report was therefore the synthesis layer above a multi-stage computational process.
The numbers came from execution.
Their meaning came from reasoning.
Evidence as a First-Class Output
For many AI systems, the final output is the response.
Once that response has been generated, the process behind it may be difficult to inspect or reproduce.
This experiment followed a different model.
The executive report was only one artifact produced by the workflow. Every completed workload also generated persistent evidence, including:
- execution identities,
- replay identities,
- execution traces,
- dataset hashes,
- capability artifacts,
- timing and runtime metadata,
- verification records,
- and machine-readable outputs.
Reproducibility was not added after the analysis had finished.
It was produced as part of execution.
The report explains the conclusions.
The evidence explains how those conclusions were produced.
Replayability
Every completed workload generated replay information allowing its execution record and stored result to be retrieved and inspected without reconstructing the original research session.
The artifacts preserved both the result and the context required to understand how it was produced.
This changes the unit of output.
Instead of existing only as text inside a conversation, a completed computation becomes an addressable artifact that can be revisited, inspected, and referenced later.
A report can summarize an execution.
A replay identity can lead back to it.
Deterministic Verification
Replayability and re-execution validate different properties, and the distinction is important.
First, a completed execution can be retrieved exactly as it was originally stored. The verification artifact confirmed bit-identical retrieval through the persisted run result.
Second, a probabilistic workload can be executed again with the same computational parameters and a new seed. The resulting distribution should not be bit-identical, but it should remain statistically consistent with the original result within the expected Monte Carlo error.
In the verification run documented for this study, the statistical comparison produced a z-score of 0.807, remaining within the expected Monte Carlo range.
These checks answer different questions:
| Verification mode | Question answered |
|---|---|
| Stored-result retrieval | Was the completed output preserved without modification? |
| Statistical re-execution | Does the computational method reproduce a consistent distribution? |
Persistent retrieval verifies the evidence.
Statistical re-execution verifies the method.
Together, they make the computational process independently inspectable without making the incorrect claim that separate Monte Carlo runs must produce identical samples.
Beyond Text Generation
Viewed from a distance, the experiment produced a wildfire research report.
Viewed more closely, it demonstrated a different computational architecture.
Perplexity Computer did not simply generate text describing wildfire vulnerability.
It designed a methodology.
It evaluated candidate data.
It constructed a canonical dataset.
It discovered computational capabilities.
It composed an execution pipeline.
It orchestrated deterministic workloads.
It verified the resulting artifacts.
It then synthesized the outputs into a human-readable report.
Language remained essential throughout the process. Reasoning defined the methodology, interpreted intermediate results, and produced the final narrative.
Computation was delegated to infrastructure designed to execute mathematical work and preserve its evidence.
Neither component replaced the other.
Language produced understanding.
Deterministic execution produced evidence.
Both were required.
Neither was sufficient alone.
Why This Matters
The significance of this experiment is not limited to wildfire research.
The same architectural pattern applies wherever important decisions depend on reproducible computation rather than explanation alone.
As frontier AI systems become more capable of planning, researching, and coordinating complex work, they will increasingly encounter tasks that language generation cannot complete by itself.
A model can propose a simulation.
It cannot substitute prose for running one.
A model can explain uncertainty.
It cannot substitute confidence for probability.
A model can interpret evidence.
It should not manufacture the evidence it is expected to interpret.
This experiment illustrates one possible division of responsibility:
- The reasoning system defines and adapts the computational plan.
- The execution layer performs the deterministic or probabilistic work.
- The evidence layer preserves the lineage required for inspection and replay.
- The reasoning system interprets the verified outputs for human use.
The result is not an AI system pretending that language is computation.
It is an AI system connected to computation it can actually execute.
Conclusion
The objective of this experiment was not to demonstrate that an AI system could produce another research report.
Many systems can already do that.
The objective was to observe what happens when a frontier reasoning model can progress beyond language and into deterministic computational work.
The wildfire assessment is one outcome of that process.
The architecture that produced it is the more significant result.
An autonomous agent independently designed a methodology, discovered and transformed public information, inspected a catalogue of computational capabilities, composed an execution strategy, orchestrated 343 deterministic workloads, and produced evidence that could be retrieved and statistically verified.
The report is useful.
The evidence is inspectable.
The computation is replayable.
Together, those properties represent a different model of AI-assisted research: one in which reasoning and execution operate as complementary parts of the same system.
That architectural boundary—not the wildfire assessment itself—is the principal outcome of the experiment.
Reasoning proposed. Execution proved.