1.9.9735 RU/EN

Багфиксы

Исправления и улучшения

• [Crash] Теперь не крашимся, если на старте не хватает прав #EA-1266
• [Scripting] Breaking change - механизм табов перенесен из EyeAuras.Blazor.Controls в PoeShared.Blazor.Controls - нужно обновить неймспейс
• [Scripting] Исправлено зависание UI(дедлок), которое могло происходить при подгрузке больших ресурсов #EA-1294
• [Scripting] Доработано управление Embedded Resources в Script Properties: список ресурсов, операции с файлами, отображение деревом, лимиты списка и сценарии с references/NuGet.
• [Scripting] EmbeddedResources теперь должно быть проще подключать - добавлена поддержка частичного совпадения по пути (/res/my.png => res/my.png и my.png найдут ресурс)
• [UI] Немного доработан редактор Send Sequence - добавил забытые ранее элементы для MouseMove
• [UI] Доработано отображение ошибок в интерфейсе #EA-1295
• [UI] Исправлена ошибка из-за которой некоторые окна не перетаскивались #EA-1292
• [UI] Небольшая правка обработки NVIDIA timestamps для режима Security measures.
• [AI] AI теперь понимает когда элементы(ауры/деревья) выгружены #EA-1265

1.9.9564 RU/EN

A small follow-up patch after the larger 1.9.9545 update. This release mainly includes fixes for EyePad, video preview, and SDK dependencies.

EyePad

Fixed file launching through EyePad.

If EyeAuras is started with a .json or .v1.enc file, that file is now treated as an aura file and launched through the aura tab. Regularly opening a .json file inside EyePad still works as opening it as a text file.

A few related fixes were also included:

• if the passed file cannot be launched, the application now exits with InvalidData
• if startup fails with an error, EyeAuras should no longer additionally exit afterward as if everything succeeded
• added E2E tests for these scenarios

Video preview

Fixed a race condition in video preview: the old frame buffer could already be freed while the UI was still trying to read a frame from it.

Now those stale frames are simply skipped or logged instead of crashing the preview.

Fixes and improvements

• EyePad .json and .v1.enc files passed on application startup now open as aura files.
• EyePad Regular .json opening inside EyePad remains text-based.
• EyePad If a file cannot be launched in one-shot mode, the application now exits with InvalidData.
• EyePad A startup error for the input file should no longer cause the application to terminate twice.
• [Image Preview] Fixed a race condition when freeing the old video frame buffer.
• [Notifications] Fixed EA-1258: the notification overlay could break after obfuscation.
• [SDK] Updated ImageSharp and Unity, and removed the old direct reference to OpenAI 1.7.2 to eliminate NU1605 downgrade conflicts.

Major update RU/EN

This update has two main focuses:

• the new Blazor interface and the gradual move away from the old WPF shell — build 9339, build 9406
• built-in AI Assistant, Discord Bot, and Codex Coding Assistant

One important user-facing AI change: free limits are now available, so you can try Assistant without manually setting up an OpenAI account. This matters especially for users in Russia: OpenAI currently blocks direct access for them, and EyeAuras Gateway solves that problem. If you want full control, you can provide your own OpenAI API key or compatible endpoint; in that mode, EyeAuras connects directly and does not use Gateway.

Other major areas in this update:

• almost all Free version restrictions have been removed; the only notable exception for now is the Network Message trigger/action. This is a leftover from the old model, and I plan to remove it in one of the next major updates
• fully redesigned pack licenses and sublicenses for pack and mini-app authors — you can now build almost any licensing model you need from the available options, for example by tracking session count or binding access to a computer
• EyePad as a separate workflow for code, .csx, .sln, Live Import, and external IDEs
• stronger C# scripting: Embedded Resources, NuGet, Memory API, Script Properties, and IDE integration
• improvements to Export / Import, pack publishing, and mini-app distribution workflows

If you're new to EyeAuras: a pack is a collection of auras/scripts, and a mini-app is a ready-to-use solution built on top of EyeAuras.

New interface and UX

The goal of this update was to bring the new and old interfaces to feature parity. Future development will continue in the new UI. The old one will be disabled in one of the next updates.

AI integration

The second main focus of this update is AI. It is now split into two usage scenarios:

• AI Assistant — a smart reference and lightweight editing mode for settings, documentation, and small examples
• Codex Coding Assistant — a much more powerful tool that can effectively write the program FOR you

Tokens, API keys, free limits, and Gateway

EyeAuras integrates with OpenAI and OpenAI-compatible APIs: you can provide your own OpenAI API key or compatible endpoint, and requests will go there directly.

OpenAI does not provide free limits for this kind of third-party integration, but I still wanted users to be able to try the new functionality without extra setup. So EyeAuras handles this through EyeAuras Gateway — essentially a proxy server in front of OpenAI. Thanks to Gateway, free limits are available for both Assistant and Codex: you can get started without a separate OpenAI account, keys, or endpoints. That should be enough for occasional AI help.

Gateway also solves the access restriction problem for users in Russia: OpenAI currently blocks direct usage there, while EyeAuras Gateway allows AI features to work without separate routing workarounds. If you specify your own API key or endpoint, Gateway is not used. In the near future, there will also be a way to top up your EyeAuras balance so that users in Russia can use AI even then.

AI Assistant as a smart reference

AI Assistant is a smart EyeAuras reference and a lightweight mode for simple changes: which trigger to use, why an action did not fire, where the right wiki section is, what a minimal C# script looks like, or what needs to be fixed in your current setup.

At the same time, EyeAuras Bot is now available in Discord. It provides the same fast help format, but outside the app: the bot knows the wiki, changelog, and scripting best practices.

The wiki is now available in both Russian and English. This matters both for users and for AI: the better the documentation, the more accurate Assistant, Discord Bot, Codex, and external coding agents become.

Codex Coding Assistant and which one to choose

Codex Coding Assistant is the stronger mode for tasks where a simple answer or a small edit is not enough. It works alongside EyePad and external IDEs: it can see workspace files and folders, keep task context, make a plan, apply edits, account for editor diagnostics, and explain what changed.

Typical Codex use cases: writing or fixing a C# script, understanding Behavior Trees, building a pack, preparing a mini-app, using Live Import, connecting the Memory API, or explaining an error directly in the context of your current project.

Codex is the future main AI mode in EyeAuras for tasks where it needs to see the whole project.

In short: Assistant is cheaper and faster for reference, ideas, or a simple edit. Codex is smarter and better for tasks like “help me do this in my project.”

Monetization

The old Free version restrictions have been almost completely removed: limits on aura count, script size, integrations, and core features should no longer be held back by the old Free/Pro model.

The only notable exception for now is around network messages: using the Network Message trigger and Send Network Message action still requires a license. This is a technical leftover from the old model, and I plan to remove it in one of the next major updates.

Overall, EyeAuras is moving toward a free core application. Monetization should shift away from restrictions inside the app itself and toward finished products built on top of it: packs, mini-apps, and author-made solutions.

Sublicenses for pack and mini-app authors

Sublicenses are no longer about restricting EyeAuras as a platform. They are about how authors can distribute their own solutions.

If you build a pack, a mini-app, or private automation for a team or client, you can now assemble a more suitable access model from the available options. For example:

• a personal license for one computer
• a license for multiple concurrent sessions
• separate access for a team or client
• limited demo/trial access before purchase
• different access levels for the basic and advanced versions of a pack

The idea is simple: EyeAuras stays as open as possible as a platform, while authors can cleanly monetize what they build on top of it.

C# Scripting

Major changes:

• added Embedded Resources for files, images, DLL/EXE files, and other resources inside a script
• improved variables and Script FileProvider / references
• added the Open in IDE button for Rider, Visual Studio, and other IDEs
• improved Live Import
• added ScriptContainerExtensions for DI and modular script architecture
• expanded the Blazor API, including custom UI widget registration through RegisterViewType(...)
• added Script Properties, NuGet management, and References and Embedded Resources

Memory API

The Memory API now has its own documentation section. It is a way to read state directly from a process. Its main use case is C# scripts, but you can also pass read values through variables.

For example, you can read coordinates, HP, the current target, object lists, and more.

What this gives you in practice compared to using WinAPI directly:

• the same script can be attached to different memory sources: a normal process, MemProcFS / LeechCore, your own driver, a dedicated device, or an external bridge such as DLL inject. In other words, you can start with something basic like LocalProcess, then change a single line and use the exact same code with a DMA device, driver, or your own ultra-secret reading method
• if you already have your own reading method, you can integrate it through a custom process or custom memory backend, while keeping the same API and all the surrounding functionality
• when you need to execute code inside the target process, there are code caves, allocation/protection/free memory, DLL inject, APC, remote thread, and manual mapping — basically everything needed for comfortable work
• EA ReProcess pack is an open-source example of how to build a full RE tool on top of Memory API using ImGui; the ReProcess API documentation describes its workspace, tabs, actions, address inspectors, and findings storage
• ReToolsPlugin can be plugged directly into your own Memory API scripts to give an AI agent reverse-engineering tools for the selected process: read memory, search data, disassemble, inspect RTTI, save findings, and continue from discovered facts

EyePad

EyePad continues to evolve into a separate working mode for users who write code, run scripts, import packs, and work with .sln.

The important shift here is that EyePad is now closer to a real work environment, not just an embedded editor. You can open individual .csx and text files, work with .sln, run Live Import, import a pack, and gradually turn an experiment into a proper project.

File handling reliability has also been improved. Drafts, saved files, external file changes on disk, and recovery after restart should now behave more predictably. This is especially important for AI scenarios: if Codex or an external agent works with a project, it needs real file context, not “magic” text living only in editor memory.

This is still not the final Explorer/workspace model, but the direction is already clear: EyePad should become a proper shell for the workflow of “write code, run it immediately, then turn it into a pack or mini-app.”

Export, Import, and mini-apps

Export / Import has been noticeably improved both visually and functionally.

What changed:

• the Export window now lets you set pack parameters, name, and description
• packaging of compiled scripts and dependencies has been improved

The goal is still the same: to bring the workflow to a point where a working mini-app can be built as quickly as possible, literally in a couple of clicks. We are already 90% there.

Image Search, Preview, and Computer Vision

Image Search now includes a built-in template editor.

You can now do all of this directly inside the trigger:

• crop the image
• erase pixels
• remove a color
• resize the template

Image preview rendering in the new UI has also been improved, template rendering issues have been fixed, and the missing SDK availability of IComputerVisionExperimentalScriptingApi has been added.

Fixes and improvements

Below is a combined list of Bugfixes / Improvements items from all changelogs included in this large update. The list is sorted by importance: crash/freeze first, then Licensing/Auth, UI, Scripting, and the remaining groups.

Crash / Freeze

• [Crash] Fixed an issue where the license window could crash on startup
• [Freeze] Fixed an issue where the BT editor could freeze when switching between auras and BT in some scenarios
• [SendInput] Fixed a rare deadlock in SendInputController that could appear in Ctrl+V scenarios
• [Share] Fixed a rare SharePreview crash
• [AI] Fixed a crash in AiChatSession related to SetInputSink

Licensing / Auth

• UI Fixed a bug where authors can once again download their own packages regardless of the configured download policy
• [Licensing] Added signed metadata and explicit limits for sublicense in the internal licensing APIs
• [Auth] Fixed a bug where a cached token could be treated as valid even though it already needed refresh, which caused unexpected logouts

UI

• [ImGui] There have been a lot of changes over the last 2 months. I recommend checking the current version — EyeAuras.ImGuiSdk, 0.1.42: markdown editor, animations, compound buttons, font integration, images, caching, and more.
• UI Fixed an issue in WindowListProvider: when a window title updated, EA could lose the window for 1 frame
• UI Improved popover window rendering performance
• [Bindings] Fixed an issue where the Bindings editor might not open as a popup
• UI Fixed an issue where deleting SubTree in behavior trees did not work
• UI Fixed an issue where the error list did not appear when clicking the icon
• UI Fixed panel resizing issues where the mouse could appear to “stick” while dragging
• UI Fixed jerks while dragging Blazor windows, where the window could suddenly jump sideways
• UI Significantly improved resize and drag behavior for BlazorWindow, so it should behave better under load
• UI Fixed border clipping in BlazorWindow
• UI Fixed IWindowSelector.FindWindow: a missing window should no longer throw an exception

Scripting

• Scripting Added the new Open in IDE button, which lets you edit a script in Rider/Visual Studio and see changes in EyeAuras in real time — [read more here...](/scripting/ide-integration)
• Scripting Embedded Resources fixes — made Script FileProvider more flexible so it now understands more path formats
• Scripting Improved script resource cleanup — even if user scripts leave behind dangling references, EyeAuras will try to clean them up once the script is no longer running
• Scripting Improved Blazor API — added RegisterViewType(Type viewType, Type dataContextType, object key = default). This allows registering custom UI widgets.
• Scripting Memory API — a huge number of performance and internal changes. At this point, Memory API can be considered stable and performant enough for almost any development scenario. Several inject mechanisms were also added (CreateRemoteThread, APC, and others). Please note: inject and memory reading depend on the protection of the specific process; games and anti-cheat-protected applications may require separate approaches, compatible access methods, or additional setup.
• Scripting Fixed an issue where ScriptContainerExtensions was being registered repeatedly by BT nodes. Because of that, singleton objects stopped being... singleton objects.
• Scripting NuGet — added DefaultNuGetPackageBlacklist, which improves compatibility with older netstandard1.3 and netstandard2 packages
• Scripting Fixed an issue where IComputerVisionExperimentalScriptingApi was unavailable in the SDK
• Scripting Reworked the script loading process — this should fix the error Could not build the proper workspace state, please report this error
• Scripting NuGet — improved package resolution and added more detailed TFM filtering
• Scripting Fixed a virtualization issue where some script files could appear in the list twice
• Scripting Improved Embedded Resources and StaticWebAssets support in NuGet packages — especially useful for UI components and packages that bring their own web resources

AI, Codex, and Discord Bot

• [AI] Two AI profiles are now created by default: OpenAI and EyeAuras Gateway (a proxy for OpenAI)
• [Discord Bot] Message edits and deletions now update the bot’s memory and history more accurately, reducing stale context
• [Discord Bot] Bot replies and service messages are now sent without accidental @everyone, role, or user pings
• [Discord Bot] Long markdown replies and code are now split into Discord messages more cleanly; artifacts can now be sent as files
• [AI] Improved Responses API: added response streaming
• [MCP] MCP in desktop AI is no longer hidden behind alpha access only
• [AI] IEyeAurasAiGuidanceService was moved out so scripts can programmatically access a guidance pack — you can load a docs pack and feed it directly to AI from inside your script, giving AI more context about your pack/app

Behavior Trees

• [BehaviorTree] Fixed an issue with cyclic references that caused the UI to show connections that did not actually exist
• [BehaviorTree] Added a new node — SetVariable. It is still at a very early stage, but I decided to ship it early just to test it
• [BehaviorTree] Improved BT performance

Input / SendInput

• [SendInput] Fixed an issue with the TetherScript driver — on some resolutions/DPI settings, mouse clicks could also shift the cursor slightly (+-1px). Also, please make sure you are using a compatible driver version so everything works as expected — HVDK 2.1, with more details on this page

Image Search / Preview

• [Image Search] Added a new built-in template editor. It lets you crop images, erase pixels, remove a color, and resize directly inside the trigger. Read more...
• [Image Preview] Improved image rendering in the new UI — previews should now look sharper, without unnecessary smoothing

EyePad

• EyePad “Recent” is now sorted by date in descending order
• EyePad AI/Codex now has a better understanding of which files and folders you are currently working with

Export / Import / Packing

• [Packing] Improved compiled script packaging — dependencies from NuGet and package references should now make it into packed builds more reliably
• [Export] Fixed an issue with aura pre-compilation during Export when Binaries Only mode is enabled
• [Export] Fixed .gitignore preservation during project export

Web / Share / SEO

• [Web] Worked on SEO (search engine optimization) — your packs should now be detected faster by search engines and appear in results more often

1.9.9516 RU/EN

AI - Agent Guidance

A new Agent Guidance page has been added to the AI settings.

In short, EyeAuras can now prepare a portable guidance-pack folder for external AI coding agents. It contains up-to-date docs, examples, SDK notes, metadata, and MCP status.

This is useful when you open an EyeAuras project, an exported workspace, or a C# project in an external agent such as Codex, Claude Code, Cursor, and similar tools. You no longer need to manually explain what EyeAuras is or where the correct context lives every time.

Important: EyeAuras now works at the folder level. Your project AGENTS.md is not changed or overwritten. The guidance pack itself includes its own AGENTS.md, which the agent can use as a starting point.

From this window, you can:

• rebuild the guidance pack
• open the folder with the generated AI-facing files
• save the pack as a zip archive
• copy the entire pack into generated/ai through the selected .csproj or .sln

The pack contains AGENTS.md, README.md, docs/, manifest.json, and, if MCP status was recorded, mcp-status.json.

The generated/ai folder is managed by EyeAuras and is fully replaced when copied again.

Read more:

• AI Assistant
• AI Codex Coding Assistant

AI - MCP helper

The same window now also includes a more convenient MCP helper.

MCP is a local bridge that lets an AI agent request targeted context from EyeAuras. The docs remain the primary source, and MCP is best enabled when the agent needs to ask EyeAuras about the current application state, windows, or available objects and symbols.

For normal wiki questions, you can safely ignore it. For external coding agents and more advanced scripting tasks, it can be very useful.

Fixes and improvements

• [AI] Fixed an issue with compacting tool calls in history (EA-1236 by S1lver)
• [Auth] Added extra protection for the refresh token flow when credentials are empty

1.9.9511 RU/EN

AI - Deeper IDE Context and Introspection

The built-in AI and Codex IDE Context mode has been improved. The assistant now has a better understanding of which script, aura, or project you are currently working with.

If the project has already been exported to disk, the AI can now use real diagnostics, symbol search, and documentation more confidently. In practice, this means that for more complex tasks it should rely on the actual project more often and guess less.

C# Overlay - Clone as Action

The C# Overlay editor now includes a Clone as Action button.

It clones the current overlay as an OnEnter C# Script action, then automatically collapses and disables the overlay itself. This is useful when an overlay started as a quick prototype and later needs to be turned into a regular action without manually copying the project.

Also fixed a transparency bug in C# Overlay that could cause the overlay to behave incorrectly.

Fixes and Improvements

• [Auth] Fixed a bug where a cached token could be treated as valid even though it already needed to be refreshed
• [UI] Fixed border clipping in BlazorWindow
• [UI] Web aura tree items now respond correctly to mouse clicks during rename

1.9.9472 RU/EN

A small patch focused on improving window responsiveness under load and helping your packs appear in search results faster.

C# Scripting - Memory API docs

New Memory API documentation for C# scripts has been added. It gradually explains the core memory model in EyeAuras: which backends are available, where to start, how to find a code cave, how to plug in your own IProcess, and how to build custom memory backends.

Useful entry points:

• Memory API - Getting started
• Memory basics
• C# struct layout
• LocalProcess
• Code Cave
• Custom IProcess
• Custom memory backends

C# Scripting - UserLicense improvements

New signed fields were added to UserLicense in the internal licensing APIs, and sublicenses now expose an explicit MaximumSessions.

var license = GetService<ILicenseAccessor>();

Log.Info($"UserId: {license.UserId}");
Log.Info($"Roles: {string.Join(", ", license.Roles)}");
Log.Info($"AppVersion: {license.AppVersion}");

if (license.ShareSublicenses.Length > 0)
{
    Log.Info($"MaximumSessions: {license.ShareSublicenses[0].MaximumSessions}");
}

Read more: Pack sublicenses

C# Scripting - Memory API - added free memory

IProcessControlApi now includes explicit FreeMemory(...) and ProtectMemory(...) methods. That means an allocated region can now go through the full lifecycle properly: get it through AllocateMemory(...), change protection, perform the required actions, and then release it cleanly.

using System.Diagnostics;
using EyeAuras.Memory;

using var process = LocalProcess.ByProcessId(Process.GetCurrentProcess().Id);
var control = (IProcessControlApi) process;

var region = control.AllocateMemory(
    IntPtr.Zero,
    4096,
    MemoryAllocationType.Commit | MemoryAllocationType.Reserve,
    MemoryProtectionType.ReadWrite);

var oldProtection = control.ProtectMemory(region.Address, region.Size, MemoryProtectionType.ExecuteRead);
control.ProtectMemory(region.Address, region.Size, oldProtection);
control.FreeMemory(region);

Read more: Memory API - Getting started

Fixes and improvements

• [UI] BlazorWindow resizing and dragging were significantly improved, so windows should behave better under load
• [Web] Improved SEO (search engine optimization) - your packs should now be detected by search engines faster and appear in results more often
• [Web / Share] Fixed a race condition when enabling code highlighting while share pages were reloading
• [Licensing] Added signed metadata and explicit sublicense limits to the internal licensing APIs
• [Loader / Remote] Improved Scryde detection

1.9.9467 RU/EN

C# Scripting - Script Properties / NuGet

C# scripts now have a Properties button that opens a separate script properties window. It brings the main settings and dependencies together in one place: Overview, NuGet package management, References for internal and external assemblies, and Embedded Resources for files that should be distributed together with the script.

Learn more:

• Connecting external assemblies
• Embedded resources

Fixes and improvements

• [AI] Codex now understands EyeAuras-specific details better, so it should be more useful for complex technical tasks
• [UI] Improved the Export and Import dialogs to make them more convenient to use
• [UI] Fixed jerky dragging for Blazor windows, where the window could suddenly jump to the side
• [UI] Fixed the ICodeHighlightService error

1.9.9435 RU/EN

AI Codex

Codex inside EyeAuras keeps getting a more practical UX: separate threads, a clearer workflow, and in general a more usable mode for complex coding tasks.

If the regular AI Assistant works better as a quick in-app chat and reference tool, Codex is already better thought of as a separate mode for heavier technical work.

Read more about AI Codex Coding Assistant

Export / Import

The Export / Import flow is also continuing to improve. It is now a much clearer and more convenient way to publish packs, update them, and import them back with previews and proper options.

Read more about Export / Import

Fixes and improvements

• [AI] Improved EyeAuras Gateway budget monitoring
• [UI] Improved code block rendering and formatting
• [UI] Fixed a bug where authors can once again download their own packages regardless of the selected download policy

AI patch - 1.9.9423 RU/EN

This update is mostly focused on bug fixes and polishing a few parts of the UI.

AI - Code Blocks

Added code rendering in dedicated blocks.

AI - EyeAuras Gateway

Added budget and limit display. Just hover over the status next to your profile.

Bugfixes and improvements

• [UI] Fixed an issue where the error list did not appear after clicking the icon
• [UI] Fixed panel resizing issues where the mouse could get "stuck" while dragging
• [Export] Fixed an issue with aura pre-compilation during Export when Binaries Only mode is enabled

1.9.9420 RU/EN

Export improvements

The Export window has been improved. You can now set packing parameters directly there, and also specify the pack name and description.

This still is not the final version of the flow. The goal for the next two months is to bring it to a point where you can assemble a working mini-app in 10-15 minutes, have AI write it for you, upload it in one action, and immediately share it with anyone interested.

Right now we are roughly 70-80% of the way there, especially after the latest fixes.

Update window and changelog improvements

The in-app update window has also been improved.

It is now easier to navigate the changelog:

• you can switch between RU and EN patch notes directly inside the update window
• changelog links were fixed and should now open the corresponding wiki pages in your browser
• image rendering inside patch notes was improved

AI - Gateway

Free limits were added to EyeAuras AI Gateway.

This was done so everyone can have AI available right away, without needing to register an OpenAI account, add budget there, or pay for a subscription. This is especially important for users in Russia, where direct access to OpenAI is still blocked.

For most users, AI will probably be more of a reference tool: quickly look something up, ask a one-off question, understand a topic, and move on. I hope the free limits will cover exactly that kind of use. For full-scale coding and serious scripting, they most likely will not be enough.

Important: AI is expensive. I reserve the right to keep adjusting these limits, their availability, and the general usage rules as the feature starts seeing real load. The program is free, and I still want at least some AI access to be available to absolutely everyone, so we need to find a balance.

AI - EyeAuras Gateway

In simple terms, EyeAuras Gateway is a special server address that you can put into the AI profile in the OpenAI Endpoint field, next to API Key and the other settings.

From the user's point of view, it is almost the same as a regular OpenAI profile, except that instead of the standard endpoint you use EyeAuras Gateway.

This is mainly useful for people who do not want to create their own OpenAI key, or who live in Russia. If you already have normal access to OpenAI, direct OpenAI is usually still the simpler option.

EyeAuras Gateway now supports two modes.

Gateway

This is the main mode. You use AI as an EyeAuras user.

In this mode, you do not need your own OpenAI account. This is how the free limits work: the OpenAI costs are covered on the EyeAuras side, and you simply use AI inside the program.

Proxy

This is the fallback mode. In it, Gateway does not pay for anything on your behalf and simply forwards requests to OpenAI servers using your own key.

This is only needed for users in Russia.

In short:

• Gateway - you want to use AI without your own OpenAI account
• Proxy - you already have your own key, but need a convenient path to OpenAI

Important: in Proxy mode, your personal OpenAI key passes through EyeAuras servers. Technically, I tried to make this as safe as possible and avoid storing or logging anything unnecessary, but it is important to understand how the setup works.

Learn more about AI Assistant

AI - Codex

Support for Codex was added. In my opinion, it is one of the strongest AI assistants available today.

From the user side, the idea is roughly the same as with regular ChatGPT: you give it a task, and the assistant tries to solve it using every tool available. The key difference is that Codex tends to dig much deeper into the problem, re-check its conclusions more often, and usually produces stronger results on complex technical tasks.

Right now, Codex and Claude Code are driving a lot of practical AI programming forward, and now this kind of integration is available here as well.

For now, Codex is not running at full power yet: not all the wiring is connected. For example, I intentionally have not connected it to the scripting system yet, even though that is one of the main future use cases and one of the reasons it was added in the first place. Automatic behavior tree generation, writing scripts, self-diagnostics in the style of "why is this not working" - these are exactly the kinds of scenarios where Codex is especially strong. But first, we will spend about a week evaluating the integration quality itself, let it work as a reference tool for now, and then give it more freedom.

Where to use it

The main use case for Codex is complex work: programming, automatic configuration of auras, trees, macros, and similar systems.

Using it just as a reference tool is a bit like using a cannon to shoot sparrows. On top of that, this kind of usage may simply be more expensive, because Codex tends to double-check itself. That is great for quality on difficult tasks, but not very cost-effective for simple ones.

You can always switch between Codex and regular Chat mode, but conversation context is not shared between them.

p.s. The UI is still under active development. This is far from the final version.

Fixes and improvements

• [UI] Fixed a bug with the StayOnTop button in the window title bar
• [UI] Fixed an issue where SubTree could not be deleted in behavior trees