Feature request: Autopilot "workspace"-awareness (edit 2025-April: and coding assistance)

Feedback Autopilot
, ,
1

Dear UiPath Development Team,

I am writing to propose an enhancement to the Autopilot feature introduced in the UiPath Community 2023.12 release. While the current functionality of converting natural language into expressions is incredibly useful and has nothing but changed the way I write “code”, I encountered a limitation when attempting to generate expressions based on context from open tabs:

Current Scenario:

  1. Step 1: I generated an expression in the file TransactionItemSpecificContentLogging.xaml.
  2. Step 2: In a second file, I wanted to reuse the same expression.
  • Prompt: “give me a recursive transactionItem LogMessage expression similar to the one in TransactionItemSpecificContentLogging.xaml”, this time for in_Config
  • Result: Received an error message: “Sorry, we couldn’t generate an expression based on your request. Please adjust your prompt and try again.”

image
image984×525 20.8 KB

I also tried systematically if the prompt knows variables from other files, but couldn’t get any related output.

It seems though that the current file is in the context, as I could create a list of all current file’s variables with their datatype!

Don’t get me wrong: That GUI element with the natural language prompt ist a shining example how to include generative AI into a LowCode tool. As a “Pro Developer” the feature fulfills many of my needs.

Expected Behavior:

When generating an expression in a different file, the Autopilot feature should utilize the context from the open tabs, allowing it to recognize and reuse expressions defined in other open files.

Benefits:

  • Improved Usability: This feature would significantly enhance the usability of Autopilot, making it easier for users to reuse code and expressions across different files.
  • Efficiency: Reduces the time spent manually searching for and copying expressions between files, thereby increasing overall development efficiency.
  • Consistency: Ensures consistency in the expressions used across different parts of the project.
  • Adherence to Emerging Standards: By understanding the context from open tabs, UiPath Autopilot would align with the capabilities seen in other AI-enhanced IDEs, such as GitHub Copilot. These tools analyze the content of the current file and the overall structure of the project to provide relevant suggestions

Thank you for considering my request. I look forward to seeing continuous improvements in UiPath Studio.

Best regards,
Christian Prior-Mamulyan

3 Likes
2

Hello @cprima!

It seems that you have trouble getting an answer to your question in the first 24 hours.
Let us give you a few hints and helpful links.

First, make sure you browsed through our Forum FAQ Beginner’s Guide. It will teach you what should be included in your topic.

You can check out some of our resources directly, see below:

  1. Always search first. It is the best way to quickly find your answer. Check out the image icon for that.
    Clicking the options button will let you set more specific topic search filters, i.e. only the ones with a solution.

  2. Topic that contains most common solutions with example project files can be found here.

  3. Read our official documentation where you can find a lot of information and instructions about each of our products:

  4. Watch the videos on our official YouTube channel for more visual tutorials.

Hopefully this will let you easily find the solution/information you need. Once you have it, we would be happy if you could share your findings here and mark it as a solution. This will help other users find it in the future.

Thank you for helping us build our UiPath Community!

Cheers from your friendly
Forum_Staff

3

Hey @cprima,

Thanks for the suggestion. We are working on a revamped experience of the Autopilot for Developers. This will include a conversational experience that can take context from current file or project. So you will be able to request activity changes based on other examples.

Thanks

2 Likes
4

Hi Alex,

thanks so much for giving this topic attention — I truly appreciate it!

Since my post last year, the space has evolved quite a bit, and through hands-on work (mostly from Python-based side projects), I’ve developed a clearer view of what a truly top-notch developer experience could look like in this domain.

More than half of the following I can do today in a OpenAI ChatGPT webinterface to their models.

Even if Studio just supported me in getting “context” out of it that would be highly beneficial. For example an export function of the project variables and arguments in the panel “Data Manager” that I could paste into a chat.

Refined RPA Copilot Developer Assistant Requirements, 2025-Q2 edition

  1. Multi-Threaded Chat per Project
    • I’d love to have multiple Copilot threads within a single project.
    • Each thread would keep its own dedicated context (e.g., coding, researching process patterns, git guidance).
    • This would really help with mental and functional separation — much like having multiple tabs in Studio, but purpose-built for the Developer Copilot.

With web frontends to chat assistants I repeatedly open new chats, actively managing context.

  1. LLM Switching per Thread

    • I’d find it valuable to choose the most appropriate LLM for each thread (e.g., GPT-4 for code-heavy tasks, Claude for broader reasoning).

  2. Context Enrichment via Inputs

    • I’d like to enhance each individual chat context by:
      • Dragging in PDFs
      • Referencing local folders
      • Supplying URLs to draw in external domain knowledge

With web frontends to chat assistants like ChatGPT custom GPTs I do that all the time, even if I just create a custom GPT in draft mode and use the preview chat

  1. Pseudocode & Code Generation
    • The Developer Copilot should be able to generate UiPath-style pseudocode (e.g., “Use Excel Process Scope → Read Range → For Each Row”).
    • It would be great if it could optionally produce .xaml fragments for manual insertion (e.g., via Clipboard AI-style copy/paste).
    • More importantly, I’d strongly prefer that the Copilot prioritizes coded automation generation (see Studio - Creating hybrid automations).
From my perspective, `.xaml` as a target format just isn’t viable for LLMs:
  • It’s too verbose, which bloats context
    • my rule of thumb in Python/JavaScript/PHP coding chats: Max 500 lines of code, beyond that the LLMs output quality is deteriorated
  • It only allows static reasoning
  • The actual logic is buried in escaped attributes and dynamic bindings

In short, trying to generate .xaml directly feels like a dead end — and with Coded Automations already available, I think the transition path is clear: DROP xaml.

  1. Auto-Documentation in Markdown
    • I’d like to have Copilot generate a Markdown “wiki page” in a Documentation/ folder when I ask it to summarize a topic or discussion
    • A simple built-in Markdown viewer in Studio would complete the loop nicely

Generating contextual README and wiki pages is truly mindblowing! GitHub does it well with the complimentary wiki repositories (for a repository foo-bar one can have a foo-bar.wiki repo that is shown in the repo webgui).

  1. Software Quality Coaching
    • The Developer Copilot could support best practices by:
      • Suggesting relevant tests
      • Recommending strong commit messages
      • Promoting consistent folder structures and naming
      • Reminding me when I overlook these steps

That is then a real assistant! (e.g. “You changed 3 files, and now are asking about a new topic, you should commit first”).

This is actually not a nice-to-have feature but a must-have: Generated code is expected to break the current implementation, and a rollback to previous version has to happen frequently. Modern AI-centric IDEs require rollback features like never before.

  1. Environment Awareness
    • The Copilot should understand:
      • Installed packages
        • and whether updates would resolve known issues(!)
      • Existing variables and arguments
      • Project structure overall
    • It could help ensure clean naming and suggest proper use of patterns (e.g., putting data into TransactionItem.SpecificContent)

The release notes of the avtivities are a top priority to get into context.

  1. Debugging Assistance
    • I’d love help with:
      • Understanding error messages
      • Knowing where to place breakpoints or add logs
      • Getting interactive suggestions for likely causes and fixes

Analog to “extract as image” I would like to “wrap in testcase”.

  1. Change Impact Analysis

    • If I make a change, Copilot could flag:
      • Dependencies that may be affected
      • Workflows that might break as a result
    • That would be a huge help in reducing regressions

  2. Pattern Recognition & Reuse Suggestions

  • The Copilot could detect repetitive logic and recommend:
    • Creating reusable libraries
    • Refactoring into cleaner sequences or workflows

The current approach I see in “Autopilot for Everyone” in UiPath Assistant is not convincing to me for the reasons

  • not project-files aware!?! The code assistant knows NOTHING about my project files, not even those I have open in the Studio!? That’s the first thing e.g. VS Code plugins for GitHub Copilot did, back in January 2023
  • context / knowledge files are administrated in the Orchestrator Tenant where I will most likely have no permissions – and it is too far away from the task at hand.
2 Likes