Edgaze
Edgaze lets creators turn AI workflows into products other people can run and pay for: on the web, through an API, or from an AI agent.
Live2025 to presentFounderEdge Platforms, Inc.
The core Edgaze platform is proprietary and closed source. Public work includes the OpenAPI specification and MCP manifests, with more coming soon.
TL;DR
- Creators publish AI workflows as products other people can run and pay for per use, instead of selling prompt packs and instructions buyers have to rebuild.
- Build the graph in Workflow Studio, publish it, and Edgaze turns it into a product page with its own input form, price, and run button.
- The same published workflow is one product in three places: the marketplace, a REST API, and an MCP client used by agents.
- The hard part is after Run: every run is a record that keeps status, output, usage, and billing in agreement, and each publish is an immutable version so updates never change a past purchase.
- Four layers underneath — product, platform, runtime, providers — with eleven independently monitored services on a public status page.
- Live and operating in production, with per-run billing and creator payouts in place. The platform is now focused on acquiring creators and buyers.
Why I started it
People were sharing useful AI workflows in a form nobody could really use.
I kept seeing the same thing: someone had worked out a genuinely useful process, but the only way they could share it was as a thread, a screenshot, a prompt pack, or a long page of instructions.
That put all the work back on the person buying it. They still had to copy the prompts, find the right tools, connect the steps, and figure out what the original creator had left unsaid. Most people never made it that far. The workflow could be good and still fail as a product because using it felt like rebuilding it.
It also left creators with a weak way to make money. They could sell access to a document, but not the result the workflow produced. I wanted to close that gap.
Edgaze began with a simple idea: if someone wants the outcome, they should be able to run the workflow, not reconstruct it.
The product
A place to build the workflow, publish it, and get paid when it runs.
Edgaze combines a visual builder, a marketplace, and the execution system underneath both. A creator builds the workflow once. When they publish it, Edgaze turns it into a product that another person can open, pay for, and run without seeing or rebuilding the graph behind it.
The buyer sees a straightforward page: what the workflow does, what it needs from them, what one run costs, and what they will receive. They provide the input and Edgaze handles everything between that moment and the finished result.
How it comes together
One path from an idea on the canvas to a result in someone else's hands.
01
Build
The creator lays out the workflow in Studio: what the customer provides, which models or tools run, how data moves between steps, and what the final result should look like.
02
Publish
They test it, choose a price, and publish. Edgaze turns the graph into a product page with its own input form, description, price, and run button.
03
Run
A buyer provides the input and pays for one run. Edgaze executes the workflow, keeps its progress and result, and pays the creator when it succeeds.
04
Distribute
The same published workflow can be shared as a page, called from a backend through the API, or used by an AI agent through MCP. It is still one product in every place.
What had to be built
Publishing is the visible part. The difficult part starts after someone presses Run.
A workflow can call several models and outside services, wait between steps, branch on a result, or take long enough for the person who started it to close the page. Edgaze has to keep that run alive, preserve what has already happened, and make the final result available when they return.
That is why every run is stored as its own record. It knows which version of the workflow was used, what stage it reached, what each step produced, and whether the buyer should be charged. The marketplace, API, and MCP server all read that same record instead of maintaining three different versions of the truth.
Model providers fail too. The runtime can move a run to a compatible fallback without changing the price the buyer saw. If a run still fails, the creator's margin is released and the buyer is not charged for a result they never received.
The hardest decisions
The product only works if execution, money, and ownership agree.
A successful run has to mean one thing everywhere.
The result shown to the buyer, the amount removed from their wallet, the creator's earnings, and the run status all have to describe the same event. I ended up treating run integrity and money integrity as separate systems to monitor because a workflow completing while its payment fails, or the reverse, is worse than an ordinary error.
A creator can improve a product without changing what someone already bought.
Every publish creates an immutable version. Existing runs and bundles stay tied to the version they were purchased against, while new buyers see the current one. That made updates safer and stopped a change in the builder from silently changing an old purchase.
The workflow should remain one product wherever it is used.
A person on the marketplace, a developer using the API, and an agent connected through MCP should not need separate builds. They all discover the same product, provide the same kind of input, pay the same price, and receive the result from the same execution system.
The system
Four layers support that experience.
Product
What people use
Workflow Studio
Build and test the graph
Marketplace
Discover and buy workflows
Product pages
Collect input and show the result
API and MCP
Run the same workflow from software and agents
Platform
What makes publishing possible
Supabase
Accounts, Postgres data, storage
Workflow catalog
Published products and immutable versions
Stripe
Buyer payments, wallet funding, creator payouts
API Vault
Encrypted model-provider keys
Runtime
What runs after the button is pressed
Execution engine
Reads the graph and schedules each step
Execution workers
Call models, APIs, scrapers, and transformations
Redis Streams
Carry progress events while the run is active
Run record
Keeps status, outputs, usage, and billing together
Providers
Where model work happens
OpenAI
GPT, image, and embedding models
Anthropic
Claude models
Google
Gemini text and image models
Azure
Managed capacity for selected hosted models
The product currently exposes eleven independently monitored services, including the web app, public API, MCP server, execution engine, workers, marketplace, payments, and the checks that keep runs and money in agreement. Their current state and incident history are public on status.edgaze.ai.
Stack
Interface
Marketplace, product pages, Workflow Studio.
Execution
Durable orchestration, workers, and run events.
Data and identity
Managed databases, auth, and storage.
Models
Hosted, creator-connected, or buyer BYOK keys.
Cloud
Azure hosts platform-funded model capacity and managed services.
Payments
Wallet and bundle checkout, creator payouts.
Distribution
The same published workflow, three callers.
Security and delivery
Where it stands
Live and operating in production, with the platform acquiring users.
Edgaze is live and operating in production, while still in public beta. Per-run billing, wallets, bundles, and Stripe Connect payouts have been active since March 2026. The API, MCP server, resumable run streaming, provider-key modes, and the current runtime contract followed as the product grew beyond the marketplace itself.
The current focus is user acquisition: bringing more creators into Studio, helping them publish workflows worth paying for, and reaching buyers through the marketplace, API, and MCP. Each surface serves a different way of discovering and running the same product, from a person on the web to a backend or an AI agent.
Feb 15, 2026
Public launch
Marketplace, workflow builder, accounts, docs, and creator publishing opened.
Mar 15, 2026
Per-run billing
Wallet-funded runs, version-pinned bundles, creator margin earnings, Stripe Connect payouts.
Jul 19, 2026
Runtime contract
Canonical public run state, resumable SSE streaming, explicit credential modes. Prompt Studio retired.
Built and operated by Edge Platforms, Inc., which I incorporated at 18.
Related writing
View all posts- Distribution Is the Other Half of the StackA workflow that is not discoverable might as well not exist. Distribution is part of the stack, not something that comes after.2 min
- Why I'm Building EdgazeThe problem is not creation. It is execution and monetization. Until money flows, none of this is real. Edgaze is the layer where workflows become something people run, not something they copy and hope works.3 min
