# Hyperspace: More Nodes Is All You Need

Nicolas Schlaepfer, Hyperspace

AI Engineer World's Fair 2024

[Talk page](https://ai.engineer/talks/-zzP0EUsZz4-hyperspace-more-nodes-is-all-you-need) · [Video](https://www.youtube.com/watch?v=-zzP0EUsZz4)

## Hyperspace: More Nodes Is All You Need

Hyperspace connects community-provided inference to an editable task graph, combining model-based planning, web extraction, contextual execution, and a Python terminal.

### Inference from someone else’s computer

[0:28](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=28s)

What would a chat experience look like if the inference came from another person’s computer? Nicolas Schlaepfer introduces Hyperspace as a decentralized AI network built from resources contributed by a community of personal-computer owners. He describes the organization as having no GPUs of its own. Its existing AI OS application, available for Windows and Mac, uses [llama.cpp](https://github.com/ggml-org/llama.cpp) for inference: in his example, a user could download the application and chat using inference supplied by someone in Belgium.

The next step is to make that network useful across different kinds of work. Schlaepfer’s premise is that **a mixture of expert models can provide a better AI experience** than relying on one large closed-source model. That preference for diversity becomes a concrete design choice in the workflow demonstrated later: different models receive different jobs.

### Turn a query into an editable plan

[1:24](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=84s)

The new product, also called Hyperspace, is intended to run on that network. It combines prompt engineering, a visual interface built with [React Flow](https://reactflow.dev/), Python execution, and RAG-like web browsing. The interface puts a graph of tasks beside generated explanations and code, making the intermediate work visible rather than presenting only a final chat response.

![Slide titled Hyperspace showing connected task cards on the left and a snake-game explanation with Python code on the right.](https://ai.engineer/api/talk-essay-media/aae0d38b9b86744cd0918500403cb0bdc5d1f96414444ebdc587aedcf55c2ebc)

Hyperspace pairs a node graph with generated output and Python code.

Planning starts with a fine-tuned model. A user submits a query, and the model produces a **directed acyclic graph**, or DAG, represented as JSON. The graph expresses a methodical plan: distinct tasks connected into a workflow, with no dependency cycle that leads back to an earlier task. This structured output gives the interface something it can display and let the user edit.

Web extraction supplies another primitive. Hyperspace uses [Puppeteer](https://pptr.dev/) and [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) in its in-house scraping pipeline, converting website HTML into Markdown that is easier for an LLM to consume. The node editor and terminal then give power users direct access to the workflow. Individual React Flow nodes generated by the orchestration model can be changed to fit the task.

### Review the graph before execution

[3:08](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=188s)

The early demo begins with a sample query. After submission, the application opens the node editor, where **HyperEngine V3**, the DAG orchestration model, streams in the plan node by node. Generation produces an editable working surface; the user does not have to accept the plan unchanged.

Before execution, the user can revise three parts of each node:

- **Title:** the name of the task.
- **Task description:** what the node should do.
- **Expected output:** what the node should produce.

The user can also add as many nodes as needed. These controls expose both the work requested and the intended result, so a generated plan can be adjusted before it is run.

![Browser showing a branching graph of task cards with editing icons and an Execute button.](https://ai.engineer/api/talk-essay-media/43957becfb0335f95a3d82c5a320b17631f6b4d9b8d3051da49c29a7f0c982fd)

A generated plan in Hyperspace’s node editor.

### Give each node the context it needs

[3:46](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=226s)

Selecting Execute produces an output for each node. Each node creates a query based on its task, combining three sources of context: **the overall goal, the local goal, and what happened in the previous node**. The overall goal keeps the task connected to the user’s request; the local goal specifies the current work; the previous result carries information forward.

For example, a Python-learning workflow could carry an earlier explanation of functions into a task about `reduce`. The query-building pattern can be expressed directly in Python:

```python
def build_node_query(overall_goal: str, local_goal: str,
                     previous_output: str) -> str:
    return "\n\n".join([
        f"Overall goal:\n{overall_goal}",
        f"Current task:\n{local_goal}",
        f"Previous node output:\n{previous_output}",
    ])

query = build_node_query(
    overall_goal="Teach Python functions through worked examples.",
    local_goal="Explain reduce with an example that sums integers.",
    previous_output="A function takes inputs and returns a result.",
)
print(query)
```

This constructs the next query; it does not execute the task. The mechanism is the explicit combination of shared purpose, current instructions, and prior output.

The demo assigns reasoning and summarization to separate models:

| Role | Model |
| --- | --- |
| Reasoning | **[Qwen2 Instruct](https://qwenlm.github.io/blog/qwen2/)** |
| Summarization | **[Llama 3 70B](https://huggingface.co/meta-llama/Meta-Llama-3-70B-Instruct)** |

Schlaepfer credits this combination with providing diverse synthesized answers. He does not specify the Qwen2 size or the exact Llama variant; the linked Llama card documents the instruction-tuned variant. In the displayed result, the graph remains visible beside generated Python explanations and code, including a `reduce` example and an explanation of object-oriented programming.

![Hyperspace node graph on the left, with a reduce-function code example and an object-oriented programming explanation in the output pane on the right.](https://ai.engineer/api/talk-essay-media/4598217858db5b0c76dbfdee7024e01d74be20918ee050773dd849f64475e562)

The task graph alongside generated Python explanations and code.

### From generated code to an execution environment

[4:30](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=270s)

When a node’s output contains Python, the user can run it and inspect the result in the terminal. The terminal opens automatically with the output, extending the workflow from generating code to executing it inside the product.

Schlaepfer presents these capabilities as groundwork for future agentic behavior. The runtime also exposes a virtual file system on the right, where the user can change directories. The intended set of agent primitives comprises **memory, Python execution, planning, and code generation**. The demonstrated editor, outputs, terminal, and file tree make those foundations tangible, while broader agentic behavior remains the direction of development.

![Browser interface with task nodes and Python output above an open dark terminal and a file-system tree.](https://ai.engineer/api/talk-essay-media/4dd11108933932aa2e749418c49c7e5741aba1f5ba39234de732e295193f562e)

Hyperspace’s terminal and file system beneath the task graph and output.

The recorded demo closes with a release forecast of the coming weeks. Back onstage, Schlaepfer narrows that forecast to later that week through a waitlist and directs the audience to the Hyperspace AI Twitter account for updates. This is the historical announcement at the [June 2024 AI Engineer World’s Fair](https://ai.engineer/worldsfair/2024), rather than a statement of present availability.

## Resources

- [llama.cpp](https://github.com/ggml-org/llama.cpp) — C/C++ inference engine with local model execution, quantization and CPU/GPU support.
- [React Flow](https://reactflow.dev/) — React library for editable node-based interfaces and interactive diagrams, with guides and examples.
- [Puppeteer](https://pptr.dev/) — JavaScript browser automation library with installation instructions and browser-control examples.
- [Beautiful Soup](https://www.crummy.com/software/BeautifulSoup/bs4/doc/) — Python documentation for parsing, navigating and extracting content from HTML and XML.
- [Hello Qwen2](https://qwenlm.github.io/blog/qwen2/) — Original Qwen2 announcement introducing the model sizes, instruction-tuned variants and evaluation results.
- [Meta Llama 3 70B Instruct](https://huggingface.co/meta-llama/Meta-Llama-3-70B-Instruct) — Official model card for the instruction-tuned Llama 3 70B variant, including usage, licensing and evaluations.
- [Hyperspace node documentation](https://github.com/hyperspaceai/hyperspace-node) — Later Hyperspace documentation covering CLI, tray and browser clients, network participation and installation.

## Slides

### Presenting sponsor: Microsoft

Microsoft is the presenting sponsor.

[0:05](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=5s) [Microsoft logo beneath the heading Presenting Sponsor.](https://assets.ai.engineer/sites/aiecode2025/sha256/5d3d51b7f4395ac7638521872389073b482489fa8b12ec0e10957e6f0474a758.webp)

PRESENTING SPONSOR

Microsoft

### Innovation and platinum sponsors

AWS is the innovation sponsor; MongoDB, Google Cloud, and Neo4j are platinum sponsors.

[0:10](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=10s) [AWS is the innovation sponsor; MongoDB, Google Cloud, and Neo4j are platinum sponsors.](https://assets.ai.engineer/sites/aiecode2025/sha256/840c9184bc2eaffc197f799ab6fa9d96dbc079ae552177ffdade49a8e0b2d846.webp)

INNOVATION SPONSOR
aws

PLATINUM SPONSORS
MongoDB®
Google Cloud
neo4j

### A peer-to-peer AI network

Hyperspace draws on community members’ personal computers for its decentralized network. Its AI OS app supports chat using inference from another participant.

[0:38](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=38s) [A slide titled A peer-to-peer AI network, with a network graphic and speaker inset.](https://assets.ai.engineer/sites/aiecode2025/sha256/28760800769dd50b1de3550b8dcf41a3c53cfced3f0555eed8dbb1e0dba811fd.webp)

A peer-to-peer Ai network

Interface text:
AIE

### Hyperspace Snake Game demo

The Snake Game example branches from a requirements task into mechanics and framework tasks, with a requirements write-up and Python code displayed alongside.

[1:32](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=92s) [Hyperspace displays a Snake Game task graph alongside requirements and generated Python code.](https://assets.ai.engineer/sites/aiecode2025/sha256/7edbd31af4f156faaa3fe6088d9d144ca394ff9abf844bec8c3a04a57bae85c9.webp)

Understand game requirements
Task Description
Study the basic requirements and mechanics of a snake game, including its rules, objectives, and gameplay.
Expected Output
Summary of game requirements
STATUS DONE

Research game mechanics
Task Description
Investigate existing snake game implementations to understand the mechanics involved in creating a game like this, including movement, collision detection, and scoring.
Expected Output
Report on game mechanics
STATUS DONE

Study game development frameworks
Task Description
Explore various game development frameworks that can be used to build a snake game, focusing on their capabilities and limitations.
Expected Output
Comparison of game frameworks
STATUS DONE

Output
Understand game requirements

Study the basic requirements and mechanics of a snake game, including its rules, objectives, and gameplay.

The Snake game is a classic video game where the player controls a growing line that moves around the screen, consuming food or other items. The objective of the game is to make the snake as long as possible without colliding with its own tail or the borders of the game area.

[Embedded images: illegible text]

The following code is a simple implementation of a Snake game using the Python curses library:

PYTHON
import random
import curses

class Snake:
    def __init__(self, screen):
        self.screen = screen
        self.direction = curses.KEY_RIGHT
        self.body = [(0, 0), (1, 0), (2, 0)]

    def draw(self):
        for x, y in self.body:
            self.screen.addch(x, y, '#')

    def move(self):
        head = self.body[-1]

Interface text:
Hyperspace BETA
NEW PROJECT
Snake Game
SHARE
EXECUTE
RUN CODE
COPY CODE

### In-house web scraping system for LLMs

A magnifying glass highlights a result card. The speaker says Puppeteer and Beautiful Soup scrape websites and convert HTML into Markdown for LLMs.

[2:12](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=132s) [Web scraping slide with a magnifying glass over search results and a presenter inset.](https://assets.ai.engineer/sites/aiecode2025/sha256/ca0aa3e4dedd872a44ad3e0b4cf1f745a072ae20b969243ecdadc61127de8d24.webp)

In-House web scraping
system for LLMs

AIE
Microsoft
smol ai

MongoDB
AI Engineer World's Fair
neptune.ai
AI Engineer World's Fair

### Node editor and terminal

A snake game task graph branches from requirements into mechanics and framework research beside an idle terminal. The speaker says users will be able to edit nodes in the DAG-based editor.

[2:36](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=156s) [A snake game task graph in a node editor beside an empty terminal.](https://assets.ai.engineer/sites/aiecode2025/sha256/965b1fa8869bcf91232fc722f6303794920734a18d08901c2ddb5bd448175a7b.webp)

NODE EDITOR

Understand game requirements
Task Description
Study the basic requirements and mechanics of a snake game, including its rules, objectives, and gameplay.
Expected Output
Summary of game requirements
STATUS DONE

Research game mechanics
Task Description
Investigate existing snake game implementations to understand the mechanics involved in creating a game like this, including movement, collision detection, and scoring.
Expected Output
Report on game mechanics
STATUS DONE

Study game development frameworks
Task Description
Explore various game development frameworks that can be used to build a snake game, focusing on their capabilities and limitations.
Expected Output
Comparison of game frameworks
STATUS DONE

TERMINAL
Terminal v 0.0.1

Interface text:
Snake Game
SHARE
EXECUTE
Terminal

### Hyperspace sample queries

The early Hyperspace demo opens with sample queries for a Bali itinerary, an e-commerce platform, and a beginner Python guide.

[3:06](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=186s) [Hyperspace landing page with an input area and example prompts for travel, e-commerce, and Python.](https://assets.ai.engineer/sites/aiecode2025/sha256/96d7bb9c59bf20d7d669f65bd211c1b61adb92d9dea92ea323631602c66b24b0.webp)

Hyperspace

What will you like to ask?

HyperEngineV3

Not sure what to ask? Try one of the following

PLAN ITINERARY
Create a 5-day itinerary for Bali, Indonesia. Search for the latest information on visiting Ubud Monkey Forest, Tegallalang Rice Terrace, Uluwatu Temple, and Nyang Nyang Beach. Find recent reviews and booking options for staying at Alila Ubud, and the current menu and reservation details for dining at Locavore.

BUILD E-COMMERCE PLATFORM
Develop an e-commerce platform for online retail. Search for the latest information on integrating payment gateways, managing inventory, and optimizing for search engines. Include current best practices and emerging trends in e-commerce.

LEARN PYTHON PROGRAMMING
Create a guide for beginners to learn Python programming. Search for the latest tutorials on basic syntax, data structures, and building simple projects. Include up-to-date resources for further learning and practice.

show more

Interface text:
Hyperspace
ALL SERVICES ONLINE
CONNECT WITH US: X

### Python learning guide prompt

The demo starts with a beginner Python query asking for current tutorials, simple projects, and resources for further practice.

[3:14](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=194s) [A prompt requesting a beginner Python guide, tutorials, projects, and practice resources.](https://assets.ai.engineer/sites/aiecode2025/sha256/4fbd02ec50238d1eb94e34fd4edb9e0fe1305c4f767f4b31fcacac718963b1f4.webp)

PROMPT

Create a guide for beginners to learn Python programming. Search for the latest tutorials on basic syntax, data structures, and building simple projects. Include up-to-date resources for further learning and practice.

### Python execution and virtual file system

The speaker points to a virtual file system that changes directories, alongside a Python threading example and terminal output. These are presented as groundwork for future agent behavior.

[4:51](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=291s) [A threading example appears above an open terminal and virtual file-system panel.](https://assets.ai.engineer/sites/aiecode2025/sha256/f89a48904dd7e30f23ae9bd3f44d2bd4eecd3ea4b97a15bc5ffc3c6781a8baf6.webp)

Concurrency and Multithreading

Concurrency is the ability to run multiple tasks simultaneously, while multithreading is a technique to achieve concurrency by executing multiple threads within a single process. Python’s threading module provides mechanisms for parallel execution.

Example: Creating and running threads

PYTHON
import threading

def worker(num):
    print(f"Thread {num} is running.")

# Create threads
thread1 = threading.Thread(target=worker, args=(1,))
thread2 = threading.Thread(target=worker, args=(2,))

# Start threads
thread1.start()
thread2.start()

# Wait for threads to finish
thread1.join()
thread2.join()

Learn Object-Oriented Programming
Task Description
[illegible]
Expected Output
OOP Concepts in Python
STATUS DONE

Build Simple Projects
Task Description
[illegible]
Expected Output
Project Examples
STATUS DONE

Understand Functional Programming
Task Description
[illegible]
Expected Output
FP Concepts in Python
STATUS DONE

Explore Libraries
Task Description
[illegible]
Expected Output
[illegible]

Practice with Exercises

Terminal
Hyperspace AI is organizing the world's AI agents.
Think Mixture of 1000s of experts, not just a few. See more at [https://aiOS.network](https://aiOS.network)

[2, 4]
120
Smallest number: 1 Largest number: 9

File System
Root
  Nodes
  Outputs
  Downloads
  Documents

Interface text:
hyperengine-web.vercel.app
Python for Beginners Gui[illegible]
SAVE
SHARE
EXECUTE
Output
RUN
COPY
React Flow
DONE Analyzing: https://medium.com/@shalum620/elevating-your-pytho...
Hide Terminal

[4:54](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=294s) [A Python learning workflow displays a threading example, terminal output, and a virtual file system.](https://assets.ai.engineer/sites/aiecode2025/sha256/7c55a9c7626d355056b86033126f87f0850faef9125e558082f13fbce6109d67.webp)

Concurrency and Multithreading

Concurrency is the ability to run multiple tasks simultaneously, while multithreading is a technique to achieve concurrency by executing multiple threads within a single process. Python’s threading module provides mechanisms for parallel execution.

Example: Creating and running threads

PYTHON
import threading

def worker(num):
    print(f"Thread {num} is running.")

# Create threads
thread1 = threading.Thread(target=worker, args=(1,))
thread2 = threading.Thread(target=worker, args=(2,))

# Start threads
thread1.start()
thread2.start()

# Wait for threads to finish
thread1.join()
thread2.join()

Learn Object-Oriented Programming
Task Description
[illegible]
Expected Output
OOP Concepts in Python
STATUS DONE

Build Simple Projects
Task Description
[illegible]
Expected Output
Project Examples
STATUS DONE

Understand Functional Programming
Task Description
[illegible]
Expected Output
FP Concepts in Python
STATUS DONE

Explore Libraries
Task Description
[illegible]
Expected Output
[illegible]

Practice with Exercises

Terminal
Hyperspace AI is organizing the world's AI agents.
Think Mixture of 1000s of experts, not just a few. See more at [https://aiOS.network](https://aiOS.network)

[2, 4]
120
Smallest number: 1 Largest number: 9

File System
Root
  Nodes
  Outputs
  Downloads
  Documents

Interface text:
hyperengine-web.vercel.app
Python for Beginners Gui[illegible]
SAVE
SHARE
EXECUTE
Output
RUN
COPY
React Flow
DONE Analyzing: https://medium.com/@shalum620/elevating-your-pytho...
Hide Terminal

### Snake game workflow

The snake game workflow branches from requirements into research and framework comparisons. The selected requirements node displays an explanation and Python code in the output panel.

[5:08](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=308s) [A snake game planning workflow appears beside game requirements and Python code.](https://assets.ai.engineer/sites/aiecode2025/sha256/68fd47229eb553173b64693583c204d6a151a5ad7d9577c0f740dec2b28d8277.webp)

Understand game requirements

Task Description
Study the basic requirements and mechanics of a snake game, including its rules, objectives, and gameplay.

Expected Output
Summary of game requirements

STATUS  NEW

Research game mechanics

Task Description
Investigate existing snake game implementations to understand the mechanics involved in creating a game like this, including movement, collision detection, and scoring.

Expected Output
Report on game mechanics

STATUS  NEW

Study game development frameworks

Task Description
Explore various game development frameworks that can be used to build a snake game, focusing on their capabilities and limitations.

Expected Output
Comparison of game frameworks

STATUS  NEW

Output

Understand game requirements

Study the basic requirements and mechanics of a snake game, including its rules, objectives, and gameplay.

The Snake game is a classic video game where the player controls a growing line that moves around the screen, consuming food or other items. The objective of the game is to make the snake as long as possible without colliding with its own tail or the borders of the game area.

The following code is a simple implementation of a Snake game using the Python curses library:

PYTHON

import random
import curses

class Snake:
    def __init__(self, screen):
        self.screen = screen
        self.direction = curses.KEY_RIGHT
        self.body = [(0, 0), (1, 0), (2, 0)]

    def draw(self):
        for x, y in self.body:
            self.screen.addch(x, y, '#')

    def move(self):
        head = self.body[-1]

Interface text:
Hyperspace  BETA
+ NEW PROJECT
Snake Game
SHARE
EXECUTE
RUN CODE
COPY CODE
Terminal
Terminal v 0.0.1
NETWORK ONLINE

## Full transcript

[0:00](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=0s) [upbeat music] Hello, everybody. Uh, my name is Nicolas Schlaepfer.

[0:16](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=16s) I'm an AI engineer. I think I'm at the right place. Um, today I'm gonna be announcing, uh, a new product we've been working on at Hyperspace. Um, a little bit about us.

[0:28](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=28s) Uh, we are a decentralized AI network. Uh, we have no GPUs. Um, we're building a community who takes, uh, the resources from their personal computer and contributes, uh, to our decentralized network.

[0:44](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=44s) Um, we have a product currently out called AI OS. Um, you can download it for Windows and Mac. It uses llama.cpp and does inference. So technically you can download it, get inference from somebody in Belgium, and you can have a chat experience like that.

[1:00](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=60s) So we're hoping to... Oh, actually, sorry. Um, we really believe in, uh, diverse models. Uh, we think, uh, not having, um, just one big closed source model is the answer for the best AI experience.

[1:17](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=77s) Um, having a mixture of a bunch of great experts will provide the best AI experience.

[1:24](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=84s) Um, so that gets us to our self-titled product, Hyperspace, which will be built on our network. Um, this is a really interesting product. It's a mix of prompt engineering, um, visual, uh, React Flow, uh, Python execution, and, uh, RAG-like, uh, web browsing.

[1:46](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=106s) So for the first thing with this product, we wanted to build a, uh, fine-tuned model that outputted agentic planning experiences. So you'd put in a query, you get in a DAG, or you get out a DAG in a JSON format, and this is a, uh, a methodical plan from that query.

[2:06](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=126s) Um, we also wanted to have a primitive of having a in-house web scraping experience for LLMs. So we're using Puppeteer and Beautiful Soup to scrape websites, convert that, uh, HTML into, uh, a Markdown, something easier to read for LLMs to digest.

[2:28](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=148s) Um, kind of the product we're gonna talk about is, uh, we have a node editor and a terminal, and this is gonna be a power tool for the power users.

[2:37](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=157s) Um, this node editor will allow you to change each node in the React Flow to, uh, fit your needs, and this is coming from the DAG org- or DAG orchestration model we have.

[2:49](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=169s) Um, here's a little video demo of, uh, our product. I recorded it yesterday in the hotel, so I'm sorry for the audio, and here we go. [gentle music]

[3:08](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=188s) Welcome to a very early look at Hyperspace. Let's begin with a sample query.

[3:20](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=200s) Once you submit your query, you're brought into our node editor view, where each node is streamed in from our DAG orchestration model, HyperEngine V3.

[3:31](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=211s) We want to emphasize that the user's still in full control. They can edit the title, task description, and expected output.

[3:39](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=219s) They also have the freedom to add as many nodes as they like.

[3:46](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=226s) Let's execute. Now that our outputs are done, we can talk a little bit about the outputs. Each output is coming from each node, and each node is creating a query based on that task.

[4:06](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=246s) It's combining the overall goal, the local goal, and whatever's happened in the previous node.

[4:13](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=253s) We're using a reasoning model and a summarization model. For reasoning, we're using Qwen2 Instruct, and then for summarization, we're using Llama 3 70B. This helps provide a diverse set of synthesized answers.

[4:30](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=270s) For the outputs that do have Python, we can go ahead and run them and see them in our terminal.

[4:39](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=279s) Terminal will automatically open it up with the output.

[4:43](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=283s) We want to provide the groundwork for agentic behavior in the future by providing these core primitives.

[4:52](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=292s) Over here on our right, we have our virtual file system that changes our directory.

[4:58](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=298s) We're trying to build out all the primitives to what an agent would need: memory, Python execution, planning, and code generation.

[5:08](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=308s) Thank you so much for watching. We're very excited to get this out in the coming weeks. [upbeat music] [audience applauding]

[5:18](https://www.youtube.com/watch?v=-zzP0EUsZz4&t=318s) Um, happy to announce that'll be available later this week via waitlist, so go ahead and pay attention to our Twitter, Hyperspace AI. All right. Thank you. That's my time. [upbeat music]
