Justin Poehnelt

Justin Poehnelt is founder and chief technology officer of Helen’s Foundry, where he leads development of its bitemporal graph architecture, verification engine, and Model Context Protocol integrations. He architected the Google Workspace CLI in Rust using AI coding agents. His work spans satellite-image search, developer tools, and agent interfaces, with concrete experiments in how agents obtain context, act through APIs, and inspect the software they produce.

From satellite imagery to developer tools

Justin worked with geospatial data at the U.S. Geological Survey and Descartes Labs. At USGS, he helped conceive and develop croplands.org, a website supporting a collaborative global cropland-mapping effort. As a founding engineer at Descartes Labs, he worked on data infrastructure and satellite imagery at petabyte scale.

He coauthored research on visual search across billions of aerial and satellite images. The team used a convolutional neural network to represent images with 512 visual features, converted those features into binary values, and searched them with a hash-based method backed by Google Cloud Bigtable. The system searched approximately two billion images covering the continental United States at one-meter resolution in about a tenth of a second. Compact representations made that enormous image collection searchable at interactive speeds.

Justin subsequently worked as a senior developer relations engineer on Google Maps Platform and Google Workspace. His open-source contributions include Maps JavaScript loading tools, React wrappers, Google Drive Picker components, and Workspace samples. These projects supplied interfaces and integration code for developers working with Google’s APIs.

Giving agents access without losing API capability

The Google Workspace CLI, or gws, brings that integration work into agent workflows, providing access to services including Gmail, Drive, Calendar, and Sheets. Rather than maintaining a fixed command for every operation, the project builds its command interface dynamically from Google’s Discovery Service. Structured JSON responses, schema inspection, pagination, and request previews let people and agents examine what an operation accepts and what a request will do.

Justin’s technical writing explains several decisions behind his approach:

• Preserve expressive requests. In his CLI design guidance, creating a spreadsheet illustrates why agents need access to raw JSON payloads: nested properties are difficult to express through a growing collection of convenience flags. Runtime schema discovery lets an agent inspect the relevant structure when it needs it. He also treats malformed model output as an input-validation problem, including resource identifiers containing query parameters and invented filesystem paths.
• Manage the cost of abstraction. His MCP abstraction tax describes a tradeoff in wrapping complex enterprise systems. A few simplified tools are easy to discover but can omit important operations; exposing every method and schema consumes the agent’s context. He favors loading task-specific instructions and schemas as they become relevant, preserving API capability without requiring the agent to carry the entire interface at once.
• Expose the running application. While building a native Rust editor for fiction writers, Justin found that an agent could change and compile the code while leaving him to launch the application, insert prose, inspect it, and relay screenshots. He embedded an MCP server in the editor so an agent could enter text, inspect diagnostics and selection state, and capture the rendered window. A separate wrapper could rebuild and restart the application while preserving the connection. The agent could then obtain feedback from the application it had produced.

What Gmail triage changed

Justin’s Gmail-triage experiment shows him revising an agent system after using it. Initially, a coordinating agent passed email bodies and headers to specialists. He changed it to pass mostly message identifiers, letting specialists retrieve their own inputs. This repeated some inexpensive reads while keeping the coordinator’s context smaller.

He also added persistent memory, then removed it when the relationship analyzer began accumulating sender records likely to become stale. These were choices about what information the system should retain, rather than an assumption that more memory would improve it.

Permissions were divided by task: the security analyzer could read messages, while the labeler could change labels without reading message bodies. An important limitation remained. Checking every email for security before further processing depended on the orchestrator following instructions; restricting each tool’s capabilities did not enforce the order of operations. Justin treated the project as an exploration and concluded that he would likely choose a different harness next time.

When a correct implementation serves an obsolete goal

Google dismissed Justin in April 2026. He became founder and CTO of Helen’s Foundry in May, alongside co-founder and chief executive Ashley Maguire.

Helen’s Foundry links strategy, goals, projects, tickets, pull requests, and code. It supplies that context to agents and checks their work against decisions ratified by people. Its defining example is a ticket that remains active after a company changes strategy: an agent can implement the ticket correctly and pass every test while still advancing an abandoned goal. The product is designed to surface that contradiction for human resolution.

Justin leads the graph architecture, verification engine, and MCP integrations behind this work. The problem extends beyond whether an agent can execute a request: the organization also needs to recognize when the premise behind that request has changed.

Away from software, Justin runs ultramarathons in Colorado’s mountains, including multiday events such as the Moab 240 and Cocodona 250. His engineering work also reaches into endurance racing: he has built embedded Rust firmware with custom LoRa mesh networking for race applications.