Binarius AI Android Code Studio — User Guide

Getting started

Binarius AI Android Code Studio is a complete Java IDE (Eclipse-based, with Java, Maven and Git support) plus an AI Assistant tab that connects to coding agents: Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, or a local model that runs on your computer.

Install

• Windows: run binarius-ai-android-code-studio-1.0.0-setup.exe. Keep Install local AI (Ollama) ticked to work offline. A Java runtime is included; nothing else is needed.
• macOS / Linux: unpack the archive and start BAACS. Local AI is installed automatically when you pick the Local agent.

First run in three steps

1. Choose a workspace folder (where your projects live).
2. On the welcome page, click Set up local AI (offline) or Sign in to an agent.
3. In the AI Assistant tab, type what you want, e.g. Create a project that demonstrates OOP concepts with tests, and press Ctrl+Enter.

Android apps

Ask for an app in plain words, for example "Create an Android notes app: a list of notes, add and delete a note, with unit tests". The agent creates an Android project from a tested template and writes the screens and the logic:

Not included: the emulator, the visual layout editor and on-device debugging. Open the project folder in Android Studio for those; both work on the same files, and the agent's changes appear there.

Android SDK setup

On first start the IDE shows Google's Android SDK License Agreement. When you accept it, the IDE installs, per user and without administrator rights:

• the Android SDK command-line tools and platform-tools (adb) into ~/.baacs/android-sdk (or uses your SDK when ANDROID_HOME points to one),
• Gradle 9.8 into ~/.baacs/gradle, used to add the Gradle wrapper to new projects.

The first build of an app then downloads the Android platform and build tools it needs (a few hundred MB, once). Downloads are checked against the checksums Google and Gradle publish. If you decline the license you can still write code; set it up later from the welcome page card Set up Android SDK.

Running on a phone

When a build succeeds, the AI tab offers Install on device and Show APK.

1. On the phone: Settings > About phone, tap Build number seven times, then Settings > Developer options > turn on USB debugging.
2. Connect the phone with USB and allow the computer when the phone asks.
3. Click Install on device; the IDE installs the APK with adb. Open the app on the phone.

Built-in Android Emulator

Try the app before it goes anywhere: after a successful build choose Run in emulator (or AI tab ⋮ > Run in Emulator). The first time, the IDE shows the emulator's licenses and downloads Google's Android Emulator and an Android 37 phone image (about 2 GB, once); it creates the virtual phone BAACS_Phone (Pixel 8), starts it in its own window, installs the app and opens it. After the agent changes the code, choose Run again. Stop Emulator closes it.

The emulator needs hardware virtualization: on Windows turn on virtualization in the BIOS and the Windows feature Windows Hypervisor Platform; on Linux, KVM. The IDE checks this and tells you what is missing.

Publishing to Google Play (testing tracks)

AI tab ⋮ > Publish to Google Play... builds a signed release bundle (AAB) and releases it to internal testing, closed testing (track alpha) or one of your custom closed tracks. Production releases stay in Play Console.

1. Once, in Play Console: create the app. For a brand-new app, Google requires the very first bundle to be uploaded by hand in Play Console (the IDE can build it: publish once as a draft and download, or use the AAB in app/build/outputs/bundle/release).
2. Once, in Google Cloud: enable the Google Play Android Developer API, create a service account and download its JSON key. In Play Console > Users and permissions, invite the service account's e-mail with permission to release apps to testing tracks.
3. In the dialog, Import service account key. It is stored encrypted in the IDE's secure storage; delete the downloaded file afterwards.
4. Upload key: tick Create a new upload key for the first release (a PKCS12 keystore in ~/.baacs/keys), or choose your existing keystore. Back up the keystore and its password: every update must be signed with it.
5. Choose the track, whether the release is available to testers or a draft, and optionally a release name, version name, "What's new" text and tester Google Groups. Click Build and publish and confirm.

Only you start a publish; the AI agents cannot publish. Testers join with the opt-in link shown in Play Console for the track.

Welcome page

Shown when the IDE starts. Cards open the AI Assistant, set up local AI, sign in to an agent, create or import projects and open settings. Clicking an example prompt puts it into the AI tab.

Workspaces and projects

A workspace is a folder with your projects. The Project box in the AI tab chooses where the agent works: one project, or (workspace folder) to let the agent create new projects. Projects the agent creates are imported and selected automatically; your next message continues on them.

The AI Assistant tab

The transcript shows your messages, the agent's replies, each tool call (e.g. Write Main.java [done]) and notices from the IDE (ℹ information, ⚠ problems, with buttons to fix them). The plan pane below the transcript shows the agent's plan when it sends one.

Agents and sign-in

Node.js is set up automatically: if the computer has no Node.js 22+, the IDE downloads the latest Node.js LTS from nodejs.org into ~/.baacs/node (per user, no administrator rights, the system is not changed), so you only sign in to your agent. Online agents are downloaded on first use (via npx) and run under their publishers' own terms. Your prompts and the files they read are sent to that provider.

Models and options

The Model box lists the models the selected agent offers; Options… holds its other settings. The list is read when you select the agent (it starts briefly in the background) and your choice is remembered per agent.

Temperature (local models)

How much randomness the model uses: 0 exact and repeatable (fixing errors), 0.2 recommended for code, 0.5 more varied ideas, 0.8–1 creative but more mistakes (not for code).

Local AI (offline)

The local agent runs a model on your computer with Ollama: code never leaves the machine and no account is needed.

• Default model: qwen2.5-coder:14b (about 9 GB; 16 GB RAM, a GPU with 8 GB+ recommended). Smaller PCs: choose qwen2.5-coder:7b in the Model box.
• Company model server: set the endpoint in Preferences > Local agent, or by admin policy.
• Settings: Preferences > Local agent (endpoint, model, temperature, max tool calls, max tokens, request timeout, Test connection).

Writing requests

• Say what you want and, if it matters, how: Create a library management system in core Java with JUnit tests; Add a REST endpoint to delete a book, with a test.
• Name a framework if you want one: … with Spring Boot and H2, … with Hibernate.
• Follow-ups work on the same project: add an interface Payable and use it in Main.
• Ask questions too: Explain this project, Why does this test fail?

The first message on a project with code makes the agent read it first and summarise it before working, so it keeps your packages, naming and libraries.

Framework and Java version

The agent reads the request first, then decides:

• You name a framework (Spring Boot, Hibernate, Quarkus, Jakarta EE…) → it uses exactly that.
• Plain programs, algorithms, OOP and data-structure demos → core Java only.
• The request needs a framework (REST API, web app, database) but names none → if one clearly fits it says which and starts; if several fit it asks you which one before creating files.

Build, test, run and fix

After every reply that changed files, the IDE checks the work itself:

1. Build the changed projects and collect compile errors.
2. Tests: if there are none, the agent is asked to write JUnit 5 tests; then they are run.
3. Main class: if a runnable program has none, the agent is asked to add one; a run configuration is created so you can run it with the Run button.
4. Run the program and read its output (servers that keep running count as started).
5. Anything failing is sent back to the agent with the errors and log, up to 5 fix rounds.

The transcript ends with ✔ Done (build clean, tests passed, program ran) or with what is still failing.

Approvals and reviewing changes

• Auto-approve on (header checkbox): the agent works without asking, like an autonomous mode. Every step is still recorded in the audit log.
• Auto-approve off: each tool call asks Allow once / Always allow for this session / Deny, and each file change opens a Compare editor. The pending changes list in the AI tab has Review, Apply, Reject and Apply all. You can edit the change before applying it.
• Allow read-only tool calls without asking (Preferences) skips the question for reading and searching.
• An admin can force review of every change and block shell commands by policy.

Switching agents and follow-ups

Change the Agent box at any time. The new agent starts on its next message, first analyses the existing code and is told which agent worked on it before and what it was asked. Use Use my last message with … in the notice to resend your request to the new agent.

Git and GitHub

Chat history

Every chat is saved per project: your messages, the agent's replies, tool calls and IDE notices, with the time of each entry and secrets removed.

Audit log

A record of AI activity for teams and compliance: sessions, prompts (secrets removed; optional), tool calls, approvals, file changes (paths, hashes and line counts, never file contents), verification results, model changes and Git actions.

Admin policy

Administrators control the IDE for a team with a policy file baacs-policy.json: allowed agents, default agent, enforced Git mode, local model server, whether shell commands are allowed, forced review, audit and chat history settings, updates. Locked settings appear greyed out with Set by your organization's policy.

Evaluation and license keys

Every installation can be used free for 28 days from its first start (the AI tab and the welcome page show the days left). After that a license key is required: at startup the IDE asks for it (Activate or Exit). Reinstalling does not restart the evaluation.

A key (BAACS1.…) names the licensee, the number of seats and the expiry date. It is checked on your computer; no internet connection is needed. Request one at the Binarius AI Android Code Studio website (License page).

Preferences

Agents table

The coding agents available in the AI tab's Agent box.

Claude Code, Gemini CLI, Codex and Copilot CLI need Node.js; the IDE installs it automatically when it is missing. Sign in once with each agent's own login (⋮ > Sign in to Agent in the AI tab) or put its API key into the agent's environment.

Local agent

Settings of the built-in local agent, which works with Ollama, LM Studio, vLLM or a company server with an OpenAI-compatible API.

Environment for all agents

Variables given to every agent, one NAME=value per line, for example HTTPS_PROXY=http://proxy.company:8080 or NODE_EXTRA_CA_CERTS=C:\certs\company.pem. Kept in secure storage. An agent's own environment (Edit…) overrides a variable with the same name.

Approvals

IDE tools

Git and GitHub

The Git mode itself (Manual, Branch or Pull request) is chosen per project in the AI tab.

Audit log and chat history

Updates

License

Where things are stored

Add .baacs/ to .gitignore if chats should not be committed with the project.

Menus and shortcuts

Updates

If your company or Binarius provides an update site, the IDE checks it at startup and offers updates (Preferences > Updates: on/off, stable or beta). Help > Check for Updates checks manually.

Troubleshooting

© 2026 Binarius Systems Private Limited · Based on Eclipse · Eclipse Public License 2.0