Influxx launched a few weeks ago with a simple pitch: describe an outcome, and the work actually gets carried out, instead of stopping at a good answer. Today that pitch gets a dedicated home for a specific kind of work — engineering. ETAPX is releasing the ADE, Influxx's new Agentic Dev Environment: a professional surface built around the real shape of software work, from multi-step coding tasks to changes that span an entire repository, instead of the single-shot chat exchange most AI tools still stop at. It's built for agentic engineers and developers who want to hand off real technical work and get back something they can actually review and ship. Consider this the chapter of the Influxx story written specifically for the people who build the software everyone else uses.
Picking Up Where the Announcement Left Off
If you read the announcement post from earlier this month, you already know the basic idea behind Influxx: you describe what you need done, and the environment carries it through however many steps that takes, checking in only when a real decision needs a human. It launched as ETAPX's third pillar alongside Whistlr and GLSRM, built for the everyday pile of tasks that are rarely difficult, just numerous — a research summary before a call, a first draft, a messy set of notes turned into something usable.
That thesis holds up well across a huge range of work, but it runs into a wall the moment the task in front of you is engineering. Reviewing a pull request is not the same shape of problem as reorganizing a project outline. Shipping a change across a dozen files is not the same as turning notes into a draft. Engineering work carries its own context — a repository's structure, its conventions, the tests that have to keep passing, the difference between a quick fix and a change that touches something load-bearing — and that context doesn't fit into a general-purpose task box any more comfortably than it would fit into a social feed or a news front page. So today we're releasing the part of Influxx built specifically for that shape of work: the ADE.
What the ADE Gives Agentic Engineers and Developers
ADE stands for Agentic Dev Environment, and the name is meant literally: it's a workspace inside Influxx built around the specific shape of engineering work, rather than a general-purpose task box wearing a developer skin. Where the rest of Influxx is tuned for the broad range of everyday outcomes — a draft, a summary, a reorganized plan — the ADE is tuned for the outcomes that matter to people who build software for a living: a change that's ready for review, a bug that's actually fixed, a feature implemented across however many files it touches, not just described in a paragraph. The underlying philosophy hasn't changed. What's changed is who it's speaking to, and what it hands back.
That shows up in what the ADE does differently from a general coding assistant:
- Built around real engineering tasks, not single prompts: you describe the change or the bug, and the ADE works through however many steps — and files — it takes to get there.
- Holds context across a whole project: it keeps track of a repository's shape and conventions across a session, instead of treating every request like the first message of a brand-new conversation.
- Treats review as part of the job: completed work comes back organized and explained, ready for a human to check, instead of a wall of code with no seams to review it by.
- Runs multi-step technical workflows start to finish: writing a change, checking it, revising it, and confirming it holds together happen as one handed-off piece of work, not a string of separate requests you have to stitch together yourself.
- Treats "hand this off" as a professional workflow: built for engineers delegating real work with real stakes, not a novelty demo of an AI writing a few lines of sample code.
Context That Outlasts a Single Prompt
Ask a chat window to fix a bug in a codebase it has never seen, and the first several exchanges are just you explaining the project before any real work starts. The ADE is built to skip that tax. Once it's working within your project, it keeps hold of the parts that matter — how the pieces fit together, the patterns your codebase already follows, the difference between a file you'd want touched carefully and one that changes all the time — across the whole task instead of forgetting it between messages. A request like "add this and keep it consistent with how the rest of the module handles errors" is something the ADE can actually act on, instead of something you have to spell out from scratch every time.
Multi-Step Engineering Tasks, Start to Finish
A real engineering task is rarely one step. Fixing a bug usually means finding where it actually lives, making the change, updating whatever depended on the old behavior, and checking that the fix didn't quietly break something else. The ADE is built to carry a task through that whole arc rather than stopping after the first plausible-looking change. You describe the outcome — the bug is fixed, the feature works, the refactor is complete — and the ADE works through the steps it takes to get there, the same way the rest of Influxx follows a research task or a draft through to completion. The difference is the vocabulary: instead of sources and paragraphs, the steps are changes, checks, and revisions.
Reviewing and Shipping Code Like a Professional Workflow
Handing engineering work to an agent only matters if what comes back is something you can actually trust enough to ship, so the ADE treats review as part of the deliverable rather than an afterthought. A completed task comes back organized enough to actually evaluate — what changed, why, and what's worth double-checking — instead of a wall of code you have to reverse-engineer before you trust it. That's the difference between a novelty and a workflow: a novelty produces something that impresses you once. A workflow produces something you're willing to put your name on.
Why the ADE Lives Inside Influxx, Not as Its Own Product
The obvious alternative to releasing the ADE as part of Influxx was releasing it as its own separate developer product entirely — a coding tool with its own brand, its own account, its own front door. We looked hard at that option and passed on it, for a reason that should sound familiar if you read the original Influxx announcement: the ADE isn't a different philosophy wearing a different outfit, it's the exact same one. "You describe an outcome and the work gets carried out, end to end" doesn't stop being true because the outcome is a reviewed change instead of a finished first draft. Splitting it into a separate product would have implied two different bets on what agentic software should feel like, when there's really only one, aimed at two different audiences.
So the ADE ships as a surface inside Influxx rather than a new destination — the same account, the same underlying commitment to following a task through to done, tuned for the specific shape of engineering work instead of walled off behind a separate sign-up. A founder who uses Influxx to clear out their inbox in the morning can open the ADE in the afternoon to ship a fix, without switching products, accounts, or mental models. The philosophy travels with you. Only the surface changes to match what you're actually doing.
"Every agentic tool that's tried to be a developer product and an everyday product at the same time has ended up unconvincing at both. The ADE isn't a pivot into developer tools — it's Influxx's own thesis pointed at a more technical audience, because engineers deserve the same seriousness about follow-through we've already built for everyone else. The work looks different. The bet underneath it is exactly the same."
— Derek Voss, VP of Product, ETAPX
That's the throughline across everything ETAPX builds: focused surfaces for different rhythms of work, connected by one account rather than one interface trying to be everything to everyone.
A Day Inside the ADE
The clearest way to describe the ADE is to describe an afternoon spent using it, because — like the rest of Influxx — the value shows up less in any one feature and more in how much of the day stops being about babysitting. It starts with a task handed off instead of a prompt typed in: fix the bug that's been sitting in the tracker for two days, add the small feature that keeps losing to more urgent work, clean up the part of the codebase everyone quietly agrees is due for it. Instead of managing that work one exchange at a time, you hand off the outcome and go do something else. The ADE works through it in the background — reading what it needs to read, making the change, checking it, revising it — and comes back to you when something genuinely needs your judgment: a design decision with real trade-offs, an edge case worth a second opinion, a change sensitive enough to deserve a second look before it ships.
By the time you circle back, there's usually a change ready for review rather than a rough attempt that still needs the real work done on top of it. That compounds fast: three small tasks that used to each eat a chunk of your afternoon become three completed changes waiting in review, and the part of your day spent context-switching between them is just free. Not because the work got easier, but because the coordinating tax on top of it — the remembering, the re-explaining, the checking back in — mostly disappeared.
"I've tried plenty of AI coding tools that are impressive on a toy example and fall apart the moment a task spans more than one file. I gave the ADE a real feature we'd been putting off for two sprints, and what came back touched the right files, followed our existing patterns, and showed up in a form I could actually review — not a diff I had to reverse-engineer before I trusted it. That's what got me to hand it something real a second time."
— Priya Nair, software engineer
That's the whole idea, aimed specifically at engineers: less time spent operating the tool, more shipped work you didn't have to write line by line yourself.
Who the ADE Is Built For
The ADE was built broadly enough to fit a lot of different engineering situations, but a few groups get something specific out of it.
Solo Builders and Independent Developers
If you're building something on your own, you don't have the luxury of a teammate to hand off the unglamorous work — the boilerplate, the small fix, the refactor nobody's excited about. The ADE is built to be that extra set of hands: the work that would have eaten an evening gets handed off instead, and you spend your time on the parts of the project that actually need your judgment and your taste — usually the reason you're building it yourself in the first place.
Small Engineering Teams
Small teams live and die by how much ground a handful of people can cover, and the ADE is built to extend that ground without adding headcount. The bug that's been sitting in the backlog because nobody has a free afternoon, the small feature that keeps losing to more urgent work, the cleanup task everyone agrees on but nobody prioritizes — the ADE absorbs the load that would otherwise fall to whoever has the least on their plate that week, which on a small team is usually nobody.
Founders Wearing the Engineering Hat
A lot of founders are still the one writing the code, on top of everything else being a founder already requires. For that specific and exhausting combination of roles, the ADE is built to take real engineering work off your plate without asking you to context-switch into managing someone else's output. You hand off the fix or the feature, keep moving on the dozen other things only a founder can do, and come back to a change that's actually ready to look at — not one more thing added to the pile.
Where the ADE Sits Alongside Whistlr, GLSRM, and Ocsidian
Zoom out, and the ADE's place in what ETAPX builds is easy to state plainly. Whistlr is where you connect and create. GLSRM is where you find out what's happening. Influxx is where you get things done — and the ADE is the part of Influxx built specifically for the getting-things-done that happens to be engineering. Worth being precise about one more product here: Ocsidian, ETAPX's agentic game creation platform built on the BlackFrost Engine, is a separate product with a separate purpose. Ocsidian is about building games with the help of an agentic environment tuned for that specific craft. The ADE is about general software engineering work inside Influxx. They share a philosophy, not a product.
The same "independence without isolation" idea that connects Whistlr and GLSRM connects the ADE to the rest of Influxx, and to ETAPX as a whole. One account carries your identity across all of it — sign in once, and the same profile and preferences that already work in Influxx travel with you into the ADE, without a separate setup or a second account to maintain. Each surface is built to be excellent at the one job in front of it. Together, they're meant to feel like one company's coherent answer to a wide range of jobs AI is actually good for, rather than a scattered set of experiments sharing a logo.
What's Next for the ADE
The ADE is rolling out now as part of Influxx, and — like the rest of Influxx — this release is a starting point rather than a finished shape. The core idea is the part we consider settled: engineering work deserves the same outcome-first treatment we've already built for everyday tasks, applied specifically to the shape that real technical work takes. Everything else — the range of engineering tasks it takes on well, how deeply it fits into the workflows engineers already live in, how much of the review process it can responsibly carry — is going to keep expanding from here.
The near-term focus is straightforward: widen the range of engineering work the ADE can carry all the way to a reviewable change, tighten the loop between handing off a task and getting back something shippable, and keep sharpening its judgment about which decisions genuinely need an engineer's eyes and which don't. None of that changes the underlying bet. It just makes the bet pay off faster, for more of the actual engineering work that fills a working week.
Frequently Asked Questions
What is the ADE?
The ADE, short for Agentic Dev Environment, is a professional surface inside Influxx built specifically for engineers and developers. It's a place to hand off real engineering work — fixing a bug, shipping a feature, working through a refactor — and get back a change that's ready to review, instead of a single-shot answer you still have to finish yourself.
How is the ADE different from the rest of Influxx?
The rest of Influxx is tuned for broad, everyday outcomes — drafts, research, reorganized plans. The ADE is tuned specifically for engineering outcomes: it holds context across a repository or project, carries multi-step coding tasks through to a reviewable change, and treats structured technical workflows as the point rather than an edge case.
Do I need a separate account or product to use the ADE?
No. The ADE lives inside Influxx rather than as a separate product, so it uses the same account and identity you already have across ETAPX. You can move between everyday Influxx tasks and ADE engineering work without switching products or setting anything up twice.
Who is the ADE built for?
Anyone doing real engineering work who wants to hand off more than a single prompt's worth of it — solo builders and independent developers, small engineering teams stretched thin, and founders who are still writing code on top of everything else running a company requires.
Is the ADE the same thing as Ocsidian?
No. Ocsidian is a separate ETAPX product for agentic game creation, built on the BlackFrost Engine. The ADE is a surface inside Influxx built for general software engineering work — different product, different purpose, though both share ETAPX's underlying philosophy of handing off real work and getting back a finished outcome.
Influxx launched a few weeks ago on a simple bet: that the point of AI was never the conversation, it was always the outcome, and the tools should finally be built around getting you there. The ADE is that same bet, aimed at the people who turn ideas into working software for a living. Hand off the bug, the feature, or the refactor you've been putting off, and come back to a change that's actually ready to ship. Agentic engineers and developers now have a home inside Influxx built specifically for them — it was always going to be next.
