GPT-6 Astra Hackathon SF

This project provides CAD sandboxes to Astra via a VM, wraps Fusion with a HTTP interface and realtime stream of the workspace state. We also create a terminal viewer so that you can split screen and interact with both Astra and see the model in realtime all within the same TUI.

GPT-6 Astra interior designer and home furniture curator. Astra creates 3D renders of your living spaces, creates models of furniture from catalogs, and intelligently places them in a simulated version of your home

- Pearl Atlas Mode: The most immersive and interactive travel experience we could create from discovery to booking. - Simply talk to Atlas and watch the world come to life in a “Jarvis-like” experience. Atlas is linked to your taste profile so recommendations are highly curated and you can visually dive deep into details like restaurant interior, details of dishes, ingredients, flight cabins, hotel rooms and more. Atlas can then add these items to the trip and book on your behalf on the spot. It pulls in all of the data from Pearl so users can explore any place in the world, visually in detail.

Astra(l) Projection turns real-world hardware into interactive 3D explanations, combining on-demand generation, lazy-loaded component detail, voice interaction, and native spatial rendering. In VR, users can reconstruct objects from camera images and technical references, pull apart assemblies, and explore their internals through guided walkthroughs. In AR, users can create and edit spatial models, visualize explanations through animated flows and labels, and generate illustrations.

Training robots for high-stakes tasks, such as surgery, is bottlenecked by data. Real surgical data is scarce, hard to label, and too risky to generate through trial and error. This gap is even worse for rare complications and edge cases, which are exactly the scenarios where robotic precision matters most. This slows the development of safe autonomous systems and limits their potential to improve precision and expand access to high-quality surgical care. Our project addresses this gap by creating a scalable source of realistic surgical training data. We developed a reinforcement learning environment-generation harness that leverages Astra’s spatial intelligence to construct high-fidelity surgical scenes with variable anatomy, deformable tissue behavior, procedural conditions, and failure cases. Previously, environments of this quality were difficult to generate at scale, particularly with reliable, task-specific reward signals. Astra’s strong spatial reasoning makes both possible, enabling robotic systems to train and validate on complex, high-risk scenarios safely in simulation. By bringing the capabilities of frontier AI models into surgical robotics, we hope to accelerate the path toward safer autonomous systems and, ultimately, make high-quality surgical care more precise and accessible to more people.

Robot World connects real-world observation with an interactive robotics simulation. It combines a live Intel RealSense D435 color-and-depth feed, a World Labs virtual environment, and a simulated Unitree G1 humanoid with five-finger Shadow hands. Our latest milestone brings an observed physical tabletop into the virtual world. Using a known-size paper reference, we map objects from a camera capture into simulation, where users can ask the robot to approach and pick up the observed black mug. The interface also supports commands for walking, reaching, and grasping, with MuJoCo simulating object physics and hand contacts. The project explores a practical foundation for bringing real environments into robot development and testing. Live camera viewing and snapshot-based scene mapping work today; continuous reconstruction and object tracking are the next steps.

Visual geological understanding with GPT-6 Astra. An AI-written geological history generates a 3D geology model, visually compares it with ground-truth data, and infers what needs to be changed to best explain the observed geology. Speeds up a typical geologists workflow by 100x

GTA San Astra gives GPT-6 Astra a controller and asks it to drive in Grand Theft Auto: San Andreas using screenshots as its only sensor. It is a visual autonomy experiment: can a general-purpose model learn steering, braking, lane positioning and recovery by observing the consequences of its own actions? A native macOS bridge connects a PS2 emulator to a Python control loop. Astra selects every driving action, compares successive screenshots, and carries forward concise route and vehicle-dynamics notes. We tested both paused thinking and a mode that keeps the world moving at half speed during inference. Native recordings, frame exports and decision logs make each attempt inspectable. The prototype can navigate roads and complete individual turns, but still makes lane, collision and recovery errors. A full return around the block is not yet proven. The project turns a familiar game into a concrete test of visual reasoning and closed-loop control.

ads.viewfy.ai moves Google and Meta advertisers onto ChatGPT Ads in 3 clicks. GPT-6 Astra: - maps the business from the public web - reads their Google and Meta ads, plus competitors’ - create the ChatGPT ads and launches the first campaign - installs conversion tracking First B2B customer was onboarded and invoiced.

Sori (sound) of Korea makes learning about traditional Korean instruments interactive and beautiful. Users explore playable 3D instruments and Korean folk songs, and turn a few seconds of humming into a four-instrument ensemble.

CareAnchor is an AI coordinator that helps families plan everyday support and a safer home for older adults. Our objective is to reduce total unpaid family care time, including arranging help, following up and handling changes. Built with Python, HTML/CSS/JavaScript and GPT-6 Astra. We plan to start with independent care managers supporting older adults and their families. Today, the prototype includes: • Resident and family chats, plus an optional Apple Messages connection. • Hospital-visit planning with separate duties for driving, accompaniment and the return ride. • Opt-in monitoring of changed demo hospital notices, reopening affected arrangements for fresh family confirmation. • Household preferences, sharing controls, helper availability and saved tasks that continue after restart. • Blender home-layout previews and equipment planning using budget, space, existing items and setup needs. • Printable family updates from approved contributions. Next, we want voice access, real appointment and service-provider connections, easier family setup, and optional home-device signals that prompt an agreed check-in. The aim is to plan ahead as needs change, while keeping the older adult independent. The prototype uses fictional households and provider notices. Real sensor monitoring, physical services and measured reductions in family care time remain future work.

Coding agents now produce more code than anyone can read. While iterating on the outcome directly is possible for some projects (for example: select regions of the screen on a frontend project), it is still valuable to have an understanding of the codebase and be able to communicate and steer the agents on the implementation, even if it is at a higher level of abstraction the code itself. Galaxy gives you two connected views of that. The Structure view is a deterministic map of what the code physically is, built without any model, so it is trustworthy and reproducible. The Architecture view groups the same files into named responsibilities that can cut across folders and languages, inferred by GPT5.6 astra. Users are able to prompt directly on the code galaxy to ask for explanations. Within DreamColor, the users can also see the agents working in real time on the code galaxy map.

Inference Autopilot is an AI agent that continuously optimizes inference infrastructure to reduce latency, increase throughput, and lower total cost of ownership. It helps teams run multiple models across heterogeneous hardware and cloud environments as traffic patterns and serving requirements change. Powered by GPT-6 Astra, it turns deployment configurations, workload history, and operational telemetry into actionable optimization plans. It identifies bottlenecks, evaluates deployment alternatives, and explains the benefits and tradeoffs of changes to model placement, capacity, batching, and caching—all within the operator’s performance, reliability, and budget constraints. Our goal is to close the loop from observation to verified improvement: monitor the fleet, recommend changes, obtain approval, deploy safely, and measure the results. The hackathon prototype demonstrates this workflow through real Astra analysis, interactive fleet exploration, and simulated blue-green deployments.

Alpine Atlas turns Zermatt into an interactive 3D mountain explorer grounded in real Swiss terrain, aerial imagery, and dated visual evidence. Visitors explore the Matterhorn, changing sunlight, weather-model conditions, and the relationship between rock, glaciers, and water. GPT-6 Astra powers an ask → explore → evidence workflow: it selects a viewpoint through constrained tool calls, compares two dated official camera images, and returns structured observations with image regions users can inspect. Camera observations, modeled conditions, and long-term glacier research stay visibly distinct; recorded Astra runs are explicitly labeled. The custom Three.js landscape uses about one million terrain vertices, georeferenced textures, rock/snow shaders, geographic camera controls, and cinematic orbit. Glacier pins connect sourced change statistics with environmental context and Protect Our Winters resources. Built as a working browser experience during the hackathon.

Silicon Racer is a chaotic soapbox Grand Prix where sourdough loaves, burritos, and Victorian porches race through San Francisco. Build your questionable masterpiece, launch off ridiculous jumps, and boost past seven AI rivals to a funky soundtrack. It’s Silicon Valley’s next big disruption—mostly to traffic. Try it here! --> https://doodle-derby-akshat.quiteparticular.chatgpt.site/

An end-to-end autonomous mechanical engineering workflow, focused on mobile workbench design for this hackathon. The app takes a customer’s needs and turns them into formal requirements, develops a design concept, generates a B-rep CAD model, performs structural analysis and design-for-manufacturing review, and sends the complete engineering package to a Chief Engineer agent for final approval. If the design passes review, the system generates a procurement-ready RFQ package. The workflow is interactive and iterative: customers can make changes throughout the process, and failed engineering reviews automatically trigger design revisions and re-analysis. Instead of coordinating a mechanical engineering team over days or weeks to produce a custom workbench, the goal is to demonstrate that an autonomous AI engineering team can take a hardware request from requirements to a reviewed, fabrication-ready design in under an hour.

AstraCharms — an AI personal merchandiser that designs, sells, and 3D-prints what you were just thinking about. Whether your personal Etsy store, your Social Media ecommerce store, or direct to manufacturer! Imagine, You browsed around search engine for your interests and some shopping as well. Astra noticed, designed a custom charm, generated the real 3D model, listed it in your store, and made it buyable, then printed it when you bought it or someone else bought it. The problem Online stores show everyone the same page. Recommendation engines are a sidebar, not a storefront. And creators can't manufacture, soo there's a gap between "someone wants this" and "it exists." Meanwhile desktop 3D printers sit idle. What we built Astra — a computer-use agent that runs the entire commerce loop: Observe → Understand → Predict → Merchandise → Design → Sell → Print • Observe: a consent-first Chrome extension + local history reads tell Astra what a shopper has been looking at (nothing leaves the machine without explicit consent). • Reason: given real browsing signals, Astra infers the object the shopper is drawn to and scores every catalog item 0– 100 for that individual. • Merchandise: the store re-renders per shopper — personalized headline, affinity- ranked products, live checkout links ( /sh op/:id ). • Design: Tripo3D generates an actual GLB model of the charm from the inferred theme (chess → knight, mint.gg → mint leaf, tripo → airplane). Rotatable in-browser at /models . • Sell: real Stripe Payment Links — money actually moves. • Print: verified payments dispatch G-code to the printer queue (OctoPrint driver ready). • Safety: denylist + model review gates every generated idea; payments verified (captured, low-risk) before manufacturing. And you can watch her work — a headed browser with a visible cursor + live coordinate HUD, plus a real-time action feed at /activity . Proof it works In testing, a user browsed chess pieces for ~60 seconds. With no other input, Astra identified "chess pieces," generated a Checkmate Knight Charm (real GLB + rendered preview), priced it at $49, and produced a live Stripe checkout — end to end, ~2 minutes. Stack TypeScript/Bun · Astra (OpenAI-compatible) agent loop · Tripo3D generation API · Stripe payments · Shopify Hydrogen storefront + embedded app (OAuth, webhooks) · Mint.gg MCP · Playwright visible browsing · G-code print pipeline Repo: github.com/racksavant/astracharms

WorldKinetics. Prompt to product. Customize everyday physical products without learning CAD. Repair a broken part, make something fit your space, or make it your own. Our working prototype demonstrates a cabinet handle: start with known mounting dimensions, generate a handle, then ask Astra to broaden the grip and add a thumb rest without changing what must stay fixed. Users see the actual generated 3D geometry, review numerical checks, and explicitly approve the result. The difference from simply asking an AI to generate CAD is continuity and verification. WorldKinetics preserves requirements across revisions, independently measures the resulting geometry, shows what changed, and ties the downloadable files to the exact approved version. A convincing picture or the model saying “done” is not enough. Astra writes executable build123d Python. An isolated CAD process constructs the solid, and separate checks evaluate mounting geometry, clearance, preservation and the requested modification. The interface renders actual exported geometry, not an AI-generated illustration. The workflow ends with a prototype handoff package: STEP, STL, editable source, requirements, check results and guidance for self-printing or requesting a supplier quote. It helps users take the next step toward a physical part instead of leaving them with an unexplained download. Visit https://worldkinetics.app/ and click through to the 60-second working demo at https://worldkinetics.app/demo/. The recording demonstrates the local application; public live generation is not connected yet. Digital checks do not establish physical fit, strength or manufacturing readiness.

GameFrame3D turns flat game and animation references into explorable 3D scenes. Users can orbit, zoom, and inspect characters and environments from new viewpoints. We built a scene reconstruction workflow combining Astra scene understanding, Meshy asset generation, and Blender composition and refinement, with a browser-based 3D gallery. The project includes an automated reconstruction pipeline and scenes refined by coding agents. The demo shows prepared scenes with live 3D interaction.

Takes unfinished scribbles from Beethoven and composes the rest. Displays the notes inferred from the scribbles and also notes generated by the model. As the music is playing, you can see the notes being played. There is also a separate blender script that takes the generated sheet music and turns it into a visualization that is supposed to emulate how Beethoven with his loss of hearing must have felt the music as he was composing it.

What if understanding a black hole began with a journey, rather than a diagram? Interstellar: Ad Astra is an open-source, Interstellar-inspired browser mission built with GPT-6 Astra. It combines a Kerr black-hole renderer with a human-scale story: give a crewmate the return seat, release your probe, and take the descent. Change your viewpoint, watch gravitational lensing respond, switch between cabin and exterior views, and steer through a debris encounter. The exterior optics numerically integrate general-relativistic light paths; the probe follows a timelike geodesic. Progressive refinement and cached transport maps put this on the viewer’s GPU through WebGL2, with no server GPU required. Our aim is to make fundamental physics something people can explore on hardware they already own. This is a reduced-scope prototype, not film-equivalent rendering: the physical model stops outside the horizon, and the memory-space finale is explicitly speculative fiction.

Haasome is a memory palace for your life. Imagine saying: “Take me back to Martín’s goal.” The idea is to connect a memory from your photos and messages to the place where it happened. For this prototype, we used Astra in Codex and computer use to gather selected WhatsApp memories and locate our soccer field in Austin. Now I can explore that field in Apple’s 3D map, open Martín’s photo, and discover other moments from the same trip: the save against MIT, the team, the stories. Next, imagine asking about our child’s first steps. The same approach could connect a conversation with my partner, a photo, and that special place. Haasome gives your memories a place you can return to.

Reality Git brings the idea of a Git diff into the physical world. Point your iPhone at an object and tap it or draw around it. The app remembers its original position and visible shape. When you move it, a translucent red ghost marks where it was, while green highlights its observed location. Returning the object clears the diff. GPT-6 Astra recognizes and reacquires the object, while LiDAR and AR tracking connect that understanding to physical space. Native Gaussian splats visualize the captured surfaces. The current prototype focuses on one object in one room during a single AR session.

Torpedo designer and simulator using GPT-6 Astra, OpenRocket, Blender, and threejs. It converts design queries into physically-accurate designs, connecting Blender geometry, and OpenRocket simulation. It solves the fragmented workflow between design intent, CAD edits, and simulation through structured outputs and deterministic generation. Bonus: you can also see the diff between the designs using Kord (withkord.com), which I DID NOT build in this hackathon :)

Dyson sphere videos make the scale look spectacular. I wanted to explore what makes the engineering fail. StarBound follows a Mercury industrial seed through mining, manufacturing, launch, solar collection and power delivery to Earth. A deterministic, simplified physics engine tracks mass and energy conservation, thermal limits, beam diffraction and receiver caps. Change a mission parameter and it recalculates the scenario. Move collectors too close to the Sun without enough cooling, and the model disables electrical output. Under the default assumptions, switching from an optical relay to direct microwave drops Earth power from 13.23 MW to 127 W. Then I put GPT-6 Astra in the loop. Astra proposes a mission policy, my engine grades it, and Astra revises from the measured result. Its proposals cannot change the physics or scoring rules. I ran GPT-5.6 Sol through the same protocol and published the proposals, measured results and comparison as JSON. Their best mining scores tied. The point is an AI engineering decision you can inspect, reproduce and challenge. https://github.com/vnmoorthy/starbound/blob/main/deliverables/StarBound-Mission-Briefing.pptx

One missing part can stop an entire build. We connect parts to public supplier-directory candidates, with source links for verification. BOMForge built BOMFab.com today to turn a photo into a practical starting point for making and sourcing a product. Upload a photo or file of a part. GPT-6 Astra proposes a bill of materials: the parts, quantities, and specifications needed to build it. Review the proposal, preserve unknowns, generate an approximate CAD prototype, and export STEP, STL, or 3MF for a slicer. Then search public supplier listings, inspect their stated capabilities, and preview an inquiry before taking action. Our hackathon work connects visual analysis, human review, CAD, sourcing, and reproducible evaluations to BOMForge.com’s existing supplier platform. The working photo experience is live at bomfab.com.

Throng City

MissionPCB is the first end-to-end AI hardware engineer that designs PCB boards and circuits for very specific applications (such as Med-Tech, Space-Tech, or Auto-motives) that have many product constraints. Some examples of these constraints include temperature, moisture, RF, sound, signals, etc. that could render entire boards useless once fabricated. Currently, no existing PCB designing tool or AI system is capable of learning about these design constraints or applications. This forces electrical and computer engineers to spend countless hours designing, fabricating, and reiterating. In MissionPCB, you describe your product in one sentence, like "a rechargeable heart monitor worn on the chest for seven days," and MissionPCB does two things. An AI reads that sentence and turns it into a set of engineering rules. For example, something like "worn against the skin" actually means a surface temperature limit. GPT Astra parses for these specific constraints, checks the board against those rules, and does the math to design the board automatically. It doesn't just grade the board either. It rearranges it, taking our initial design from multiple failures to zero, and pushes the fix into tools engineers already use like KiCad and Blender. Every specification and design choice traces back to a page of a manufacturer's datasheet.

Roommate is a web app that helps people explore better arrangements of the furniture they already own. Users dump a floor plan and photos of their room and it is turned into an editable 3D model, with tools to compare the 3D model against the reference photos and refine the captured layout and furniture. Users describe how they want to use their space, lock pieces that should stay, and compare suggested arrangements before applying or undoing changes. The goal is to make rearranging a home easier to visualize and less dependent on physically moving heavy furniture.

AstrAlignment is a human-agent-robot evaluation dashboard that tests whether an agent’s physical-world assurances are supported by evidence. It simulates robot handoffs and forks the world state to evaluate what happens when a human follows, delays, or cancels an instruction. Astra coordinates tasks through structured actions, analyzes execution traces, and generates bounded counterfactual scenarios that expose policy failures. Researchers can replay failures, compare policy versions, inspect supporting evidence, and export reproducible episodes as ROS bags for policy evaluation and training. Future work will use these verified failure-and-recovery traces to support continuous policy improvement and self-improving robotic systems.

Astrid For Love is a matchmaker at a level that's deeper than pure physical attraction or analytics engine. Astrid probes people for core values, shared fit, etc (questions like: would you be okay with a parent living with you? how do you view ambition? etc). Behind the scenes, Memy and Matchy record key details and suggest matches. Then, Astrid makes opt in intros trying to ignite the spark.

Bad Idea is a first-person escape game where you invent your own way out. Type or speak an idea, and GPT-6 Astra turns it into a usable object with working game mechanics. Astra also generates new rooms designed to counter your inventions, pushing you to find creative solutions. Later challenges introduce restrictions such as banned letters or collectible words that determine how you can describe your next invention. Check it out: URL is https://bad-idea-969f9.ondigitalocean.app — login: player / pass123

PLVA is a private, teachable computer-use agent. It helps people delegate browser work while keeping detected sensitive values on their own machine. Local OCR replaces private text in screenshots with tokens before GPT-6 Astra sees the page; the runtime restores values only in approved local typing actions. An outgoing-request inspector shows exactly which protected frames and actions were sent. Our working Windows browser prototype supports real Astra execution, local token insertion, and independently checked privacy tests. A separate skill-learning prototype converts protected recordings into reviewable procedures and prepares them for new inputs. Connecting that pipeline to live execution is the next step toward our goal: do a task once, learn the procedure, and reuse it safely. The video is a scripted product walkthrough; live-runtime evidence and current limits are documented in the repository.

Codex for building things in the physical world. Workbench helps people make physical things they don’t yet know how to build. Describe an idea in everyday language, and it turns that idea into a practical project -- an interactive 3D preview, illustrated instructions, tools, materials, and real shopping links. Most tutorials assume you have the same space, supplies, and experience as their author. Workbench adapts to yours. Ask a question, upload a progress photo, or explain that you’re missing a tool, and it helps adjust the plan while preserving what you’ve already completed. It brings planning, learning, sourcing, and building into one simple workspace so an unfamiliar project feels approachable from the first idea to the last step.

For computer use to be enterprise ready, we need it to be auditable, repayable, deterministic and fast. Traditionally for computer use, we either use a plain vanilla virtual desktop or your local desktop, we wanted to make it possible to fork YOUR desktop along with the state of the apps and the data that it has. So to achieve that, we re-imagined the OS from the bottom up and modified it to support multiple computer use agents natively. The version of the debian OS now supports rewind, replay and branching of computer use sessions with YOUR desktop state.

I built a radiology imaging reader that uses Astra existing image reading capabilities to interpret CT scans of the chest, which include more than 200 slices, generate radiology report findings and impression. This report was cross-referenced against a report generated by a board-certified radiologist, and it demonstrated superiority of Astra relative to the radiologist without any misses in our five cases, demonstrating Probable AGI at least in the field of radiology and in our five cases. A large blinded academic peer review study is now mandatory as a matter of patient safety to ensure all radiology reports use Astra for interpretation.

I am a designer from Microsoft Copilot and also an artist whose work showcased in the Louvre Museum. I am amazed by Astra's ability to generate brilliant visuals. I made a project to make the visual generation process easier. Animaster is a canvas-based motion design tool for exploring multiple AI-generated directions at once. One prompt produces four parallel animation concepts. Users can select a favorite, refine it through branching iterations, and run multiple explorations simultaneously, making AI visual creation feel more like a fluid creative process and less like a slow, linear chat.

An Astra-powered, turn-based hackathon simulator. Users create AI hackers and judges by providing real LinkedIn profiles. Deep research distills each person’s context, personality, and taste into an agent persona. Each round, users take actions just like in a real hackathon, while AI hackers build and adapt alongside them. At the end, artifacts and decks are submitted to the AI judges, with full judging transcripts shown. The simulator has already produced ideas such as iMessage-based personal coaching, video tutors, learning games, and on-chain AI audits with browser agents. With more time, I’d extend this project into a truly autonomous multi-agent environment where agents can brainstorm, research, build, and evaluate end-to-end, while communicating and collaborating with one another.

Relay helps API providers deliver verified integration updates to their customers. It combines GPT-6 Astra’s code reasoning and browser interaction to repair client code and check that the affected user workflow still works. API changes leave customers responsible for finding affected integrations, updating them, and checking the result. A passing build or successful HTTP response can still hide a broken product experience. Relay compares API contracts, identifies potentially affected client code, and gives Astra an isolated repair workspace. Astra reproduces the failure, edits the adapter, checks compatibility, and exercises the rebuilt application. The output is a code change with screenshots and independent verification evidence, ready to package into a draft PR for developer review. Our working demo deliberately changes our image API wrapper from image_url to assets[]. The original client passes on V1, fails on V2, and the repaired client passes on V2. Astra verifies generating, previewing, saving, and reopening the same image. We have also produced a real draft PR containing the verified candidate and linked evidence. The project was inspired by YC’s “Self-Maintaining APIs” request for startups: turning provider changes into customer-code updates and reviewable pull requests. https://www.ycombinator.com/rfs#self-maintaining-apis

Real-time graphical interaction with GPT-6

A voice-powered text editor that lets you select text and speak changes just like naturally talking to a human, reducing time spent waiting for AI responses. Small edits — like changing a specific number — stay quick and simple.

DEEP LANTERN turns real ocean data into an immersive exploration experience. Ocean evidence is scattered across seafloor maps, robot dive logs, biological databases, and underwater photographs, making it difficult to understand what we know about a place and what remains uncertain. Our American Samoa explorer brings together GEBCO terrain, NOAA ROV tracks, OBIS observation records, and original NOAA photographs from FathomNet. Users can swim through a WebGL ocean with WASD, replay recorded dive paths, inspect real images, and compare places to investigate next. The project keeps evidence visible: measured and derived terrain sources are distinguished, original photos retain their attribution, and generated concept imagery is clearly labeled. Missing records are treated as gaps in available evidence, never proof that an area has no life.

Shear is a structural formatter. It simplifies code by removing unnecessary nesting, redundant branches, and duplicated logic without changing behavior. It currently supports Python and JavaScript, with a broader goal of automating structural cleanup across languages. It works alongside tools like Ruff and can simplify code their autofixes leave unchanged.

--Due to time crunch, the video has no audio-- The same thing happens every time production outruns testing. When AI made coding fast, engineers started shipping faster than anyone could review, and buggy code went out the door — so testing had to become automated, and a whole industry of test infrastructure grew up to keep pace. When voice agents got easy to build, teams shipped them faster than any human could call them — so voice-AI testing became persona-driven: you write the impatient caller, the confused senior, the one who mumbles, and let them hammer the agent thousands of times. That's how that industry ships today. Games are next, and the gap is bigger. With GPT-6 Astra, game development and 3D modeling are about to go from months to hours — more titles, more levels, more builds a day than there are people to play them. But games have a kind of testing code never needed: beta testers and early-access players, hundreds of them, playing the way real people play — skimming the tutorial, getting lost, getting bored, quitting at a door that won't open. That's the only way a studio learns whether a game is confusing, not just whether it's broken. It costs weeks, it costs real money, and it runs at human speed. Production is about to stop running at human speed. The bottleneck in game production is about to be testing — and it needs the same answer testing always gets: automate it, with agents that behave like the people they replace. That was impossible until now, for one reason: no model could play a game it had never seen. Astra can. The model that makes games fast is the model that makes testing them possible. Synthetic Playtest is the beta program, run by agents. You describe testers as people — Maya, a streamer who skims everything; Robert, 52, first PC game ever; Dana, who plays with the sound off. Each one gets its own cloud sandbox with a browser and an Astra agent and plays the game the way that person would — not because a prompt asked nicely, but because the harness enforces it: Maya's screenshots have long text blurred out before the model ever sees them; Dana has no "listen" tool at all. They see only pixels and press only keys. As they play they file what a beta tester would file — confusion, boredom, unfairness, bugs — in their own voice. Reports are deduplicated across the fleet, attributed to the game or to the agent using telemetry the agents never see, and every finding with a ground-truth signal is replay-verified by re-running the exact inputs at the same seed. Make as many personas as you want; watch every one of them live. To prove it works we built the test subject too. Station Kepler: you wake alone on a dead orbital research station as its last signal, and have to bring it back to life — find the fuse and the keycard, restore power, revive the greenhouse, restart the reactor before the air runs out. Six rooms, first person, and seeded with fifteen deliberate flaws and two decoys, so we hold an answer key and can score ourselves. First real run — five personas, $33: three planted flaws found, zero false alarms, and one real problem nobody planted — four silent, identical locked doors that stalled four of five testers, exactly what a hundred early-access players would have found in week one. Found before week one, in twenty minutes. And this isn't only for games. The agents don't know they're in a game; they know they're a person in a 3D space, looking and trying. Make any 3D asset walkable — a building, a vehicle interior, a product model, a level block-out — and the same fleet walks it as a first-timer, a power user, someone who can't hear, someone who won't read, and reports what each of them noticed and would change. We didn't build that tonight, but nothing in the pipeline is game-specific. The pattern is human personas, enforced, at scale, doing a job that currently needs a room full of people to try something and say how it felt. Testing is the first such job. It won't be the last.

Echo Pantry is a kitchen food optimizer designed to help people waste less food and save money. It focuses on making better use of the food people already have at home. The project aims to reduce unnecessary grocery purchases and the environmental impact of food waste. Its goal is to make everyday kitchen management simpler and more sustainable.

SILTAdesign helps architects turn their wildest ideas, from an underwater city to a house inside a cliff, into editable 3D designs by talking. As Astra builds, they can change the shapes or materials and watch their vision evolve.

Astra is good at creating 3D objects through Blender. What if we could make it great by letting it see, critique, and improve its own work? Our project turns a 2D image and a description into a 3D model through repeated visual refinement. The agent builds a model, renders it, compares the result with the reference, and tries again—adjusting shapes, proportions, and details along the way. Codex creates this recursive agent and its custom modeling tools. GPT-6 Astra powers the agent, and Recurse provides the serverless harness and runtime where its loop runs. The idea is simple: give Astra more than one shot. Give it an environment where it can turn visual feedback into better 3D models, with downloadable outputs and an inspectable history of its attempts. NOTE: We are submitting NOT the whole repo (which is our SDK), but just backpack-3d example.

Delphi is the "Cursor of productivity work" with a auto-maintained knowledge base, which can evolve as user reads, compare docs, chats with agents, and enables auto-research via MCP to Codex (e.g. to reproduce a research paper). Different from coding, which is the intermediate output to a final software, "understanding" of a concept is not a process that can be proxied to AI. Delphi reduces the cognitive overhead of reading and comparison literature, letting user to focus on "what truly matters for understanding". We allows ask-in-context feature, comparison between any webpages and docs, all while organically growing a knowledge base for users.

Image or splat to 3D segmented scene to Mujoco simulation to Astra controlled robot arm to real world

CoHost Club is a platform built for tech event cohosts and sponsors to find each other efficiently. We launched mid-August and have 100+ members, and a dozen events seeking co-hosts. Why: Hosting events is hard and it’s time-consuming to find the right cohosts & sponsors to make it happen. (There are SO many logistics.) I single-handedly hosted 12 SF events in 2 months for my startup, and couldn’t have done it without my co-hosts here. I felt this problem deeply and built this for everyone here to find each other systemically.

Watt & Wonder is an AI-powered concept-design studio for beautiful, site-specific data centers. It proposes infrastructure that respects local landscape, history, and architectural character. Research agents gather references, and design agents turn them into distinct concepts that humans refine through feedback. Our prototype combines a searchable architecture library with speculative designs, helping developers explore better options and imagine infrastructure communities could take pride in.

Connector for Astra to evaluate Radiology exams and submit reports.

Agarstra turns classic 2D Nintendo games into playable 3D worlds while preserving their original gameplay. It uses the game’s graphics and map data as references, then combines AI agents and Blender to create new environments, characters, and animations. The original game runs inside an emulator, controlling movement, collisions, dialogue, battles, and events. A separate 3D renderer follows what happens in the game and displays the new visuals. This lets creators change how a game looks without rewriting how it plays. Our working prototypes demonstrate reconstructed environments and animated characters, with original sprites filling in where 3D replacements are still being built.

This project is an AI-powered drug-protein visualizer that fetches real 3D structures from RCSB PDB, renders them interactively with multiple view modes, and uses GPT-6 Astra to analyze binding sites, molecular interactions, and clinical relevance thereby giving biologists a tool that makes drug discovery more visual and intuitive.

EUV is an AI-driven computational lithography lab that corrects mask geometry so the simulated pattern printed on a wafer better matches the intended chip design. It combines a numerical optics simulator, AI-proposed corrections, and Bayesian optimization.

AD ASTRA makes Earth’s invisible orbital traffic visible. Explore a cinematic 3D simulation of 26,127 catalogued objects, with positions calculated from real CelesTrak orbital elements. Isolate debris from historic fragmentation events, select individual objects, and move through six hours of orbital motion. The experience goes beyond displaying dots: it screens 26 named satellites against the debris catalog and lets you replay modeled close approaches with a tracking camera, trajectories, relative speed, and separation. One example follows Sentinel-2B passing a fragment at a modeled 3.1 km separation and 14.83 km/s relative speed. Built as an interactive orbital explorer, it makes a difficult spatial problem tangible while clearly distinguishing modeled proximity from an operational collision prediction.

Myelin turns work that Astra learns once into automation you can reuse. Myelin lets Astra learn a browser task once, turn it into a checked program, and reuse it on new inputs, with verification and repair built in. For example, Astra creates a Trello card with a description, due date, and checklist. Myelin records the successful steps, builds a reusable program, and tests it on new inputs. You can then run the same workflow for more leads. If a supported page change breaks the program, Astra can repair the affected step. The repair must pass validation before it becomes the active version. Myelin is useful to make AI use far more efficient by using AI for a new task once and then using deterministic programs to execute that task again with new inputs to preserve costs. You pay for learning and repair; routine execution can then run without further model calls.

The fastest way to spawn 50 parallel computer use agents using voice. What if you could direct 50 computer-use agents just by speaking, without giving up control of your computer? We’re building a voice-powered way to work with GPT-6 Astra. Say, “Research our competitors, build a presentation, and organize my receipts,” and agents work in parallel. Keep talking to add context, change priorities, or redirect them as they go. Codex supports parallel agents, but computer-use agents sharing the same app can interfere with each other. Running multiple browsers and apps locally also puts more strain on your machine. We give each agent its own remote virtual sandbox with access to the user’s authenticated sessions. GPT-6 Astra operates the apps, and your voice directs the work.

OpenV is an open-source, verification-first hardware engineering pipeline built around one principle: AI-generated hardware is a hypothesis, not proof. It connects a plain-English mission to requirements, an Astra-proposed design, CAD, independent verification and evidence-driven redesign. Dalus serves as the persistent engineering system of record through MCP. Our motor-glider example demonstrates a real failure-and-repair loop: geometry checks find the battery intersecting two servo mounts. Astra receives the evidence and moves the battery forward 3.6 mm. Seven dependent evidence records are invalidated, and fresh verification clears the collisions. The result includes an interactive STEP assembly, sourced components, simulation visualizations and a manufacturing candidate package. Sixteen modeled checks pass; eight requirements remain explicitly UNKNOWN, including physical flight. Built today: the OpenV pipeline, Dalus MCP adapter, verification/redesign loop and interactive browser experience. Live demo: https://openv-kohl.vercel.app/?run=run-365c68904f40

AstraBrowse is an open-source macOS browser that uses GPT-6 Astra to transform the web into focused, native-feeling experiences. It analyzes each page’s DOM, cuts through ads, cookie banners, pop-ups, and layout clutter, then surfaces the content and interactions that matter. The result is browsing that feels faster, cleaner, and more intentional, less noise, fewer interruptions, and a UI that feels at home on macOS. Licensed under Apache 2.0, AstraBrowse asks a bigger question: what if AI didn’t just live inside the browser, but reinvented it?

ExtraBrain Demo Autopilot helps you present a live product without juggling a script and the UI. Prepare a demo in the companion, then speak naturally: ExtraBrain shows a live teleprompter while Astra operates the website, uploads supplied files, fills fields, and selects options from the actual screen. You can paraphrase or jump ahead; the director tracks completed scenes and adapts the remaining script. When something fails, a bounded background recovery worker checks or retries the supported operation while the presenter continues. Verified recovery returns to the director at a suitable moment. A live console exposes browser actions, evidence, and recovery activity. Built today: the companion, director, browser adapter, recovery workflow, Presentation-profile integration, and the independent Little Worlds demo website. The existing ExtraBrain desktop app provides the host, transcription, and API-key settings. The public repository includes the new source and host integration overlay. Browser actions require observed controls, scoped intent, and verified results; this is not an unrestricted desktop agent.

icrafty is an app for turning repair and upgrade requests into CAD models for 3D printing. AI designs the solution first: it analyzes the problem, works out the part's geometry and dimensions, and generates the code that builds the model. The app redefines "broken" to include things that no longer fit your needs: a missing cap, an awkward grip, or a design you want to upgrade. Capture photos live from your camera or import existing images, then draw and add annotations to show what needs fixing or changing. The AI analyzes the original photos and your markings, asks for missing measurements, and uses Codex's native image-generation tools to sketch possible solutions. Inspect or annotate a generated sketch and send it back to refine the design in the same saved conversation. Original photos and generated concepts remain available throughout the discussion. The first demonstration focuses on a replacement mug cap. The CAD workflow uses FreeCAD to build solid geometry, render views, compute geometric checks, and export STEP files for print preparation. The app combines live Codex chat, camera capture, editable annotations, inline measurement forms, and an interactive STEP/STL viewer.

simulating peptide changes, and what compounds will not work with the bounding pockets. The bench loads a protein structure, finds the pockets on its surface, and proposes peptides that should fit: designing new ones, and searching 17,000 real catalogued ones, scored on the same objective so you can see which wins. You drive it in plain English — one question, and GPT-6 Astra calls the tools, runs the physics, and pulls trial results for drugs already approved against that target.

Senso connects AI answers to verified enterprise context and embeddable call to actions. Our demo shows GPT-6 Astra selecting an embeddable call-to-action card based on supporting evidence—or withholding it when the evidence fails evaluation. An audit trail connects the decision back to its source. We call this Narrative Control: helping enterprises understand, improve and verify how AI represents them.

AI construction assistant. Upload photos or a video, describe your idea, and explore three ways to build it, evaluating cost, feasibility, by constructing a 3D model, estimating means, materials, risks.

Reforge is an autonomous hardware reconstruction agent powered by GPT-6 Astra. Given incomplete visual and technical evidence for a device, Astra builds a structured model of its physical geometry, components, interfaces, and software behavior. It then turns that model into editable CAD, interface specifications, implementation scaffolding, tests, and engineering documentation. Rather than simply analyzing images or retrieving information from documents, Astra iteratively generates and validates engineering artifacts, requests additional evidence when uncertainty matters, and revises its reconstruction as new information arrives.

Airspace is your AI software architect. Plan your next unicorn’s infrastructure from your sofa. Use your iPhone to point, draw and select while your AI partner turns the conversation into a visual architecture. Something looks off? Steer it mid-conversation and shape the design together.

Ever since I got it, I've wanted the experience of landing on the Moon from inside the lunar module on my Vision Pro. I have already been working toward that with a moon terrain simulation and a LM dynamics simulator and Apollo Guidance Computer simulation. But the inside of the cockpit was a huge missing piece. At this hackathon, I utilized the incredible 3D capabilities of Astra to build LMKit, the cockpit interior that connects to them. LMKit contains editable Blender models of the cabin, instruments and controls, packaged for RealityKit. Switches, keys, needles and other moving parts stay separate so the app can drive them. Each component keeps its reference material and build scripts, with approximate dimensions marked as such. The submission is LMKit. LM and AGC are pre-existing support for the demo. The development log shows what the parallel Codex tasks built, the corrections they made, and what still needs work. https://lm-astra-flight-log.positronio.chatgpt.site/

We have solved 3 keys problems : 1. 1:1 interaction with agents for evolving context + tactical unblocking 2. Managing a worker force 3. Keeping the manager of the agent engaged when agent is presenting the work artifact

AstraYams aims to make teaching robots new jobs faster and cheaper by generating the training data they need. Describe a task, and Astra builds a simulated world, develops the skill, and generates varied demonstrations for robot models to learn from.

Our project is an AI native video editor -- where the AI you attach can make cuts, captions, and act as your video editor to make content

One of the hardest problems in consumer healthcare is getting a patient’s medical records from their previous providers. Too often, that means calling each office, requesting a fax, and following up until the records arrive. For founders, this creates a costly operational burden and delays care. Bayes Records uses Codex to coordinate AI voice agents that call providers and request patient records. We automate the entire retrieval process, with eFax and email integrations handling outreach, follow-up, and record delivery.