Agent mode

Agent mode enables conversational development inside Appfarm Create. Describe the desired app or functionality and follow along as the agent goes through the implementation tasks. The agent is currently limited to certain parts of the platform, see Current limitations.

Getting started

When your Solution has no apps, the Apps page will prompt you to describe an app for Appfarm AI to build with agent mode.

Screenshot of the Apps page in Appfarm Create with a prompt to build a new app.

Once a prompt has been submitted, the agent will create a plan for building the app, breaking the request down into implementation tasks. You can refine the plan by asking the agent to add, revise, or remove tasks.

Once you're satisfied with the plan, click Build App. The Appfarm AI sidebar will open with your initial prompt and the list of implementation tasks, and the agent will automatically start working on the first task.

Working with the agent

Tasks and changes

Changes made to your Solution by the agent are not automatically saved to the database. The changes the agent makes remain local to your browser and appear in an Unsaved changes list at the bottom of the Appfarm AI sidebar. You can click any item in the list to jump to its location in Appfarm Create. Once the agent completes a task, you can review the changes and choose to save or revert them. Changes can't be reverted or saved while the agent is working.

When you save changes made by the agent, Appfarm Create will create only one transaction in the change history for undo/redo. The transaction can include multiple changes. The undo/redo entry states how many items were changed.

When starting from a plan or handling a complex request, the agent creates tasks to track the work. The task list appears at the bottom of the Appfarm AI sidebar, as shown below. As each task is completed, its status is updated. Click Save & Continue to save changes and start the next task.

Error handling

Like any AI tool, the agent can make mistakes. These mistakes may result in bugs in your app, such as faulty logic in an action or suboptimal UI. You can resolve these issues by prompting the agent—see the Prompting guide for effective techniques—or by fixing them manually.

The agent may also make changes to your models that aren't technically valid in Appfarm Create. When the agent completes an operation, all changes pass through a validation layer. If any errors are detected, these are automatically sent back to the agent, which will then attempt to fix them. If the agent can't resolve the errors after several attempts, it will pause and ask whether you'd like it to continue.

Please help us avoid errors and improve the agent by providing feedback when you encounter issues and click the or button after the response provided by the agent.

Threads

A thread is a conversation with the agent that may include a list of tasks. When you send a message to the agent, the entire thread is sent as context along with the status of all associated tasks. By default, Appfarm Create starts a new thread on a fresh reload of your Solution.

  • Start new thread: Click the icon in the top right corner of the Appfarm AI sidebar.

  • Show thread history: Click the icon in the top right corner of the Appfarm AI sidebar to view your ten most recent threads in the current Solution. Select any thread to continue the conversation and complete unfinished tasks.

  • Resume a previous thread: Open the thread history and select the thread you wish to continue.

When a thread gets too long, Appfarm AI will summarise it behind the scenes. If tasks exist, those will remain in their full form.

Prompting guide

Prompting refers to how you formulate instructions to Appfarm AI. When using Appfarm AI in Agent mode, the way you formulate and structure your prompt directly influences the end result. A good prompt is specific and provides necessary context. When building apps, you will achieve best results by starting small and working iteratively.

Be specific

  • When building new apps: Instead of "Build an inventory management app", be specific about what you want to build: "Build an inventory management app for mobile devices, with a dashboard, UI and logic for managing tools, and checking tools in and out of storage". You can use bullet lists to describe functionality.

  • When extending functionality: Instead of "Build a dashboard", be specific about what it should show and for who: "Build a professional-looking dashboard for managers to get an overview of current tool status, with tiles for tracking current status and a line chart showing check-outs for the last 7 days".

  • When improving functionality: Instead of "Make this look better", be specific about what you want to change: "Improve the UI of this dashboard with a more modern design including cards, KPIs and charts".

  • When debugging: Instead of "My app is not working, can you help?", be more specific about what is not working: "When clicking this Submit button, nothing happens. Can you identify and fix the error?".

Provide context

Being specific is great, but in many cases, the agent will benefit from additional context. For example, what is the industry you are building your inventory management app for? Who are the users? Is there existing software you can reference with similar functionality to what you are looking for?

  • When building new apps: "Build a field operations app" has little context. Appfarm AI would benefit from knowing where, when, or by whom this field operations app should be used. Try instead "Build a mobile field operations app for construction workers to register deviations with categorization and image upload, and to register receipt of material on the construction site".

  • When extending functionality: Instead of "Create functionality for generating an order confirmation", try to add some context (and be more specific): "Extend this action: Add functionality for generating an order confirmation for customers submitting wedding cake orders from our website, and send the confirmation as an email attachment to the customer".

  • When improving functionality: When improving UI for example, more context could be beneficial in many cases. For example, from "Improve this action" to "Improve this action: Add error handling and user feedback for non-technical users".

  • When debugging: Add as much context as possible, and be precise: "This action is not working" could instead be "This action works for me in the development environment, but not for end-users in production. Security setup looks correct. Can you help me identify potential issues, and then suggest some fixes?".

Start small - work iteratively

Appfarm AI enables you to build apps from scratch, with a planning process as the starting point, resulting in an agreed scope and a set of tasks. The agent is instructed to always use an MVP approach when building full apps, but you will still benefit from trying to keep the scope down ("start small") in your prompt. Appfarm AI is great at extending functionality for the app later.

A reasonable initial scope is an app containing < 15 tasks in the planning process. However, note that some tasks could be small, and others large. For example, the agent could generate a task "Create all views", which could be huge if the initial scope is to create a complete CRM system with 50 object classes (database tables), and they should all be accessible in the app.

A good rule of thumb is to try to limit the number of entities requested to < 10 at once. For example, instead of "Create a full CRM system with the same core functionality as state-of-the-art CRMs", try "Build a simple and modern CRM for the sales department of our B2B office equipment company called {Company Name}. The app should have functionality and UI for tracking, adding, and editing Companies, Contacts, Leads, and Sales Activities, along with a Dashboard with Sales KPIs". This prompt is specific, has context, and starts small (with a given set of 4 main entities). And the app can easily be extended once created.

Custom agent knowledge

The agent is instructed to follow a defined "best practices" for building Appfarm apps. Both with regards to preferred components for various constructions and use cases (e.g. "use Dialogs for adding/editing new records"), but also with regards to naming (e.g. "a runtime only datasource for the Project object class, should be named Project (temp)").

You may override these instructions with your own custom Agent knowledge. Agent knowledge is located in the Settings in Appfarm Create (found in top-left menu, or Thread/AI Panel menu).

How the agent works

When you give the agent a task or prompt, your application model is sent as context. Based on its system instructions, the custom agent knowledge, and the current location/selected component in Appfarm Create - the agent determines the intent, identifies the available tools and determines which ones to use. Through these tools, the agent learns how the many building blocks work in Appfarm Create. It then issues commands to insert, update, or delete parts of the application model. These commands function identically to actions performed by a human user, so the same guardrails and rules apply.

Read more about our approach to AI.

Current limitations

The agent is currently able to work with the following concepts in Appfarm Create:

The agent is currently limited to working on smaller apps and will return an error if asked to modify large, complex applications. We currently recommend using it primarily for building new apps from scratch.

Within the scope of Apps, the AI has not yet been instructed to build

  • Custom Components

  • Advanced charts / Gantt

The AI can not work on multiple Apps at the same time. When starting a thread to build an App, we recommend that you do not navigate inside other Apps while the AI is building the App, as it may confuse the AI where it should be working. This will be adressed in a later version.

Last updated

Was this helpful?