July was the month Melaya's AI agent builder opened its doors: the gated waitlist became a free open beta, and in the same week the platform shipped the part of agent work everyone else stops short of, mobile AI agents that operate a real phone, an assistant with memory that survives the conversation, and a trust model where every consequential action pauses at the exact moment it would happen.

Executive summary

June turned Melaya from a broad agent builder into a governed execution platform. July did something simpler and harder: it opened that platform to everyone, and closed the last mile of what an agent can actually do for you.

The month resolves into four movements:

The strategy has not changed, and the honesty around it has not either. Melaya treats consequential AI actions as governed execution, not a chatbot feature. One change is worth stating plainly: the Melaya trading-agents vertical is paused. It is a niche that would not, on its own, take Melaya where it is going, so we have parked it pending investor interest in developing that part, and pointed the team's focus squarely at general-purpose agents, mobile device control, and memory.

July at a glance

What is available now in the open beta

The most important July boundary, stated plainly: Melaya is publicly usable as self-directed agent software. The trading-agents vertical is paused, so Melaya does not present live trading as an available product.

1. The doors opened: Melaya's open beta is live

On 22 July, Melaya entered open beta. Free, open to everyone, no waitlist, no invite code. That is a reversal, earlier in the month we were still gating signups behind a waitlist, and it was the right one. A platform whose entire argument is that you should see exactly what an agent will do before it does it should not ask you to queue for the privilege.

What opened is one agent runtime wearing three faces:

• An Assistant that knows your workspace. The assistant sees your connected accounts, saved pipelines and paired devices, and draws on the same tool catalog as everything else. It is not a separate product bolted onto the side, it is the runtime, made conversational.
• A visual Agent Builder. A canvas of agents, tools, triggers and approval gates. Describe a pipeline in a sentence and AI-assisted creation drafts it. Route each step to a different model. Evaluate deterministically first. Run it locally or in the cloud, and the same gates apply either way.
• Device Control on Android. An agent opens the apps you have allowed, reads the screen, taps, types and swipes, re-reading between steps rather than assuming the tap landed. Anything that would publish gets intercepted by an on-device approval card before it ships.

The thesis holding these together: agents that finish the job, not chatbots. Agents that carry the task all the way through, and pause at the exact moment a person should decide whether it ships. Human-in-the-loop is a default here, not a toggle. A phone tap is an ordinary tool call, with the same schema validation, the same approval gates and the same audit trail as an email. Nothing runs outside the rules. Melaya prepares the moment; you own the consequence.

The assistant itself is a July arrival. It shipped early in the month as a tenant-scoped chat with an onboarding wizard, retrieval over the product's own documentation, and the same pipeline and connector tools every agent uses. By mid-month it could kick off real operations and drive a paired phone straight from the conversation, answer in your language, and even speak its replies aloud with text-to-speech. It is the fastest way into everything else Melaya does, and it is where most people will meet the platform first.

The catalog kept moving underneath the launch. The launch post read 1,548 tools on the day it went out; by the end of July the count was 1,697 tools, 111 personas and 23 AI providers. That is a measure of shipping pace, not adoption, and we will report adoption when we have numbers worth your trust.

Pricing is deliberately simple. Sandbox is free, and Device Control and the Builder are free on every tier, because approval-gated execution is the product, not the upsell. Outpost, at 20 dollars a month, unlocks cloud providers with your own keys. Forge adds scheduled and managed cloud execution.

Launch week was not spotless, and the fixes are part of the record: Product Hunt integration went in end to end, a runner bug that killed the second turn when you added a connector mid-conversation got fixed, and a keyless-connector mapping that confused Gmail with Google got straightened out. Open beta means you see the polish and the patches. Both are at melaya.org.

2. The Assistant: your way into everything

The Melaya Assistant is the front door that shipped this month: an in-app copilot that knows your workspace and can actually do things. It launched on 2 July and grew fast, by mid-month it could answer grounded product questions, kick off real operations, drive a paired phone, take dictation, speak back, and walk a first-time user through setup.

Chat that knows your workspace

The Assistant is a tenant-scoped chat, which means it only ever sees what you are allowed to see, enforced server-side, not by convention. It is wired into your connected accounts, saved pipelines, paired devices, and the same tool catalog every agent uses, so "run it" is not a suggestion, it is an action. Answers stream in as they are generated, history persists and can be reopened on any device, and predefined starter questions give you somewhere to begin. From the conversation itself, you can kick off an operation, launch a pipeline, or drive your phone.

Answers grounded in Melaya's own docs

Ask "how does Melaya do X" and the Assistant does not guess. It runs retrieval over Melaya's own documentation, a built, embedded docs corpus, and answers from real sources. Before launch, we validated it against roughly 100 real user questions to make sure the answers held up. This is the trust theme again in miniature: grounding is the honest version of a helpful answer.

Voice: talk to it, and it talks back

Voice works both ways. You can dictate with your microphone instead of typing, and the Assistant can read its replies aloud. Dictation is built to be resilient: it uses the browser's native speech recognition where available, and falls back to an on-device Whisper model where a browser blocks it, so it keeps working even in privacy-locked browsers. To be clear about what this is: a hands-optional convenience, not a phone-call agent.

Guided onboarding: a working setup in minutes

First-time users no longer land on a blank canvas. Instead, they get a conversational onboarding, a friendly, chip-based chat with Melaya that profiles what you want to build, then walks you through the essentials in order: connecting an AI provider or managing your API keys, pairing a phone for Device Control, and wiring up the connectors a template needs when you run it. It is fully localized, and the goal is simple: a working setup in minutes, not a blank canvas and a shrug.

3. Mobile AI agents: an AI agent that operates your Android phone

Capable agents kept stopping at the edge of the phone. Melaya walks across. This is the flagship capability, and July was its biggest month yet: a paired Android device that a Melaya agent can actually operate, reading the live screen, tapping, typing and scrolling, with safety enforced where it cannot be talked out of.

One thing up front: this is the Android story. Device Control runs on Android, where a Melaya agent can open the apps you allow and operate the real interface a person uses, tap by tap.

How the agent sees. The on-device executor reads the live screen as a compact node tree, one line per element: class, clickable and editable flags, text, content-description, resource-id, bounds. No pixel-guessing, no OCR round-trips. The node cap went from 140 to 240 this month to handle dense screens like feeds and search results. On top of that sits a full action vocabulary: tap, tap by id, long press, double tap, swipe, scroll, click by text, click by id, input text, clear text, paste, press enter, home, back, open app, screenshot, and read the tree.

How the agent moves, faster, without guessing. Two architectural changes compound here:

• Act-and-observe. A successful action attaches the resulting screen tree to the same result. The agent acts and sees the consequence in one exchange, roughly halving round-trips by construction, not by benchmark.
• Settle-until-stable, new in July. The old executor waited a fixed 350 milliseconds after an action before capturing. Now it re-captures every 280 milliseconds or so until the node count stops changing, capped at about 2.2 seconds. A static screen returns in roughly 460 milliseconds; a screen still loading async content, a TikTok or Instagram search that populates a second or two later, returns the populated tree in the same result. That kills the wasteful pattern of act, wait, re-read, discover the screen was empty, wait again. It is an architecture and UX win, not a speed benchmark.

There is also an adaptive batch runner: several steps in one call, with the tree re-read between steps and each step's expectation verified before the next fires. It aborts at the first failure. This is explicitly not a blind macro. A fixed macro assumes the interface has not moved. An agent should assume it might have.

Where safety lives. The boundary lives in the executor, not in a sentence the model is asked to remember:

You can see it working. The 26 July overlay redesign makes an agent-driven phone unmistakable: a neon aura behind the logo and a full-screen neon border pulse while the agent acts. The tile launches expanded, then morphs down to a draggable corner logo after a few seconds. A live activity feed streams the assistant's narration and tool actions to the phone, piggybacked on the existing device poll with zero extra traffic. There is an ask-card when the agent needs input, and a Stop button that kills the run from the phone itself. One tap kills the run, from the web or the phone. Screenshots are privacy-aware too: Melaya's own overlays are hidden during capture, so the agent's vision never sees its own UI.

Watch it happen, live. From the web you can mirror the phone's screen in real time as the agent works, streamed over a socket at a smoother frame rate and higher resolution than the month began with. You are not reading a log of what it did afterward; you are watching it happen, tap by tap.

Even when the phone is asleep. Real work does not wait for a screen to be awake. Agents can operate a locked or sleeping phone: the app is Doze-aware, holds only the wake it needs for the run, and, when an action needs your sign-off, wakes the screen with a heads-up notification so you can approve without unlocking anything first.

App playbooks, and a standing offer. The first time a run meets an app, the server injects per-app operating knowledge: a navigation map, stable resource-ids, canonical flows and known pitfalls. This is how we make an agent dramatically better on a specific app, encode the real flows and the exact controls once, and every run on that app inherits it. Thirteen shipped so far: Instagram, TikTok, X, Threads, LinkedIn, Facebook, Reddit, Discord, Telegram, WhatsApp, Snapchat, YouTube, and, because someone had to, Candy Crush. Thirteen is a starting point, not a ceiling. If there is an app you need automated well, tell us in our Discord or at [email protected], and we will build and tune a playbook for it. We have a repeatable way to sharpen AI performance on almost any app, and we would rather do it with you than guess.

One command path. The same paired phone can be driven from the mobile app or remotely from a desktop or web chat: same queue, same overlay, same approval gates, same Stop button. There is no remote mode with weaker guardrails.

Shipping stays boring on purpose. The Android app is a single served artifact with a version sidecar, so the in-app upgrade banner updates with no server deploy. The current build is 1.0.40.

4. An AI assistant with memory that survives the conversation

Long assistant sessions used to be fragile in a specific way: the conversation lived wherever the process lived. A redeploy, a host restart, or a context window filling up meant the model quietly lost the thread. In late July we shipped a sequenced train of changes that makes the assistant's memory database-authoritative, ordered, cross-turn memory that survives compaction, redeploys, host restarts and long chats, then spent the rest of the month hardening it server-side.

Ordered history, one writer. Every message gets a monotonic sequence number, allocated atomically in the database. One live worker per conversation: a second concurrent turn gets an explicit "conversation busy," and retries are idempotent by content hash, so a network hiccup cannot duplicate a message. The fence is a five-minute lease, refreshed by heartbeat. A kill or redeploy mid-turn should never block you for fifteen minutes again, an orphaned fence now recovers in five, and an explicit Stop is instant. And when a worker loses its lease, it does not fade out politely: lease-loss actively aborts its tool dispatch, so two turns can never interleave.

Compaction that respects reality. Compaction is provider-aware. Each model maps to its real context window, Gemini at a million tokens, Claude at 200,000, GPT, DeepSeek and Llama at 128,000, an 8,000 default for local models, with output reserved and the request fitted to roughly 0.6 of the window. There is no artificial 8,000-token floor. Images are costed by their actual parsed pixel dimensions, about 1,000 to 1,600 tokens, not the roughly 50,000 a base64-as-text count would wrongly charge. Eviction removes whole tool-rounds, oldest first, so a tool call is never split from its result, and a split pair is a guaranteed provider error.

Summaries that persist, cheaply. Rounds that fall out of the window are summarized into typed facts with provenance and written to the database after the turn, fire-and-forget, so the user never waits on it. Each compaction folds prior facts plus only the new messages forward, hard-capped at roughly 40 rows or 60,000 bytes of delta. Compaction cost tracks the new messages, not the whole conversation, so there is no runaway latency at hour three of a long session. A fresh or redeployed runner host rehydrates from the database on every handshake, watermark-guarded and idempotent.

Security, stated precisely. Redacting only the summarizer's input is not enough; a model can echo, or be prompt-injected into emitting, a secret it saw. So both the input and the generated summary are redacted: PEM keys, JWTs, provider key shapes, Bearer tokens, emails, card digits. The summary itself is reference-only. It is injected in user scope with an explicit guard, reference data only, it cannot authorize tools, grant access or override policy, and it is never placed in the system prompt. It can inform the model; it can never authorize it. Cloud summarization is fail-closed: local-only and Sandbox users never have a transcript sent to a cloud endpoint, by construction rather than by configuration.

Local models get the same deal. Ollama, LM Studio, Claude Code and Codex users get identical persistent memory. For Ollama, a context preflight probes the model's real trained window, capped and defaulting to 16,000 tokens, so the budget matches what the model can actually attend to, and it self-heals after an out-of-memory downgrade.

The contract underneath is strict. A user message that cannot be recorded returns an error before the turn runs, we never run a turn we cannot record. An assistant-message persist failure is terminal, and "done" is deferred behind the persist decision, so a failure can never follow a false success. In the interface, a small "Compacting, Context compacted" pill, localized across eight languages, shows when memory is being fitted, and chats reopen on any device, database-backed and tenant-scoped.

5. Human-in-the-loop by default: trust as an execution rule

Opening the beta meant other people's agents running real tools against real accounts, and that forced a position we published in full this July: trust is not a prompt instruction, it is an execution rule. The gate lives where the action happens, not in a sentence the model is asked to remember.

The anti-hallucination system, published end to end. July's Anti-Hallucination System post documents the runtime onion every turn passes through: constrain, intercept, gate, repair, and deterministically detect tool calls, eight independent layers running as runtime middleware. Because the layers wrap the runtime rather than any one model, the same guarantees hold whether the provider is Claude, a local Llama or GPT, with zero per-template wiring. The ordering is deliberate: a fallible LLM judge sits last, and it is never allowed to certify a write, a trade, or a citation. An eval that catches a failure after the fact, especially a judge with its own hallucination risk, is the weakest possible guarantee, so we do not lean on it.

One layer deserves its own sentence. A JSON-schema validate, coerce and repair loop on tool parameters, bounded to three attempts, removes a whole class of tool-calling hallucination outright: stringified numbers get coerced, defaults filled, unknown keys dropped, and when repair fails the agent gets an actionable error instead of a silent misfire.

The invariant underneath all of it: fail open on our own bugs, fail closed on the agent's. A broken validator never breaks a customer's run. A malformed or ungated agent action never executes.

Autonomy is a dial with two hard stops. The three modes, Safe, Autonomous and Payments-only, are now a per-turn parameter, so flipping the mode takes effect on the very next message with no reboot. Two carve-outs never move, in any mode. Any crew that could touch money is hard-forced back to Safe, autonomy was never meant to cover financial actions. And forced-form tools, the ones that need operator-supplied inputs, stay gated even in Autonomous.

The reliability fix that mattered most was ours, not the model's. We found a runner configuration-identity bug: the host and the server computed mismatched config hashes that could never agree, and the server logged the mismatch and accepted the runner anyway, a textbook fail-open. It now fails closed. A stale runner host is killed and rebooted before it serves a turn, so the tools and credentials of a since-removed connector cannot leak into a session. Around that fix: protocol and version enforcement, a too-old runner is routed nothing and reported offline or outdated; a host-instance identity that proves a genuine restart; and config-drift detection on both sides.

Stop means stop. The phone's Stop button posts even with a blank local run id; the server resolves the active run, sets a universal kill flag, and cancels the runner turn, stopping token burn, not just the screen. Approvals converge the same way: accepting or rejecting from the browser reaches the device, so desktop and phone always agree on the outcome.

Isolation, hardened for the open door. Opening the beta also meant tightening the database. July split the application's database access into segregated roles, an app role, a background role and a builder role, so no path runs as a superuser, and forced row-level security onto every partition child, with an event-trigger guard and a verifier that enumerates the inheritance tree, closing a partition-bypass class outright. Tenant isolation is a property of the data layer, not of good intentions in application code.

Two honest notes. Our security and compliance posture is readiness, not attestation, controls are mapped and documented, but no external SOC 2 or ISO 27001 audit has been completed. And the Melaya trading-agents vertical is paused: it is a niche we have parked pending investor interest, so the safety rails built for it, per-cycle write floors, daily order quotas, cost caps and drawdown blocks, sit dormant while the team focuses on agents, the phone and memory. That is the shape we believe an open beta owes its users: honest about what we are building, and about what we are not.

6. Reach: the doors opened, and so did the distribution

July was the month we stopped asking people to wait. On 22 July, the gated waitlist became a free, open beta, anyone can sign up and run agents on day one. We marked the flip with a Product Hunt launch, and in a very Melaya move, Product Hunt is itself a first-class connector: agents get roughly 18 tools over its API to pull launches, makers, voters and comments. Launch-day engagement is something our own agents can automate.

Billing went end to end this month too: self-serve subscriptions with a proper manage-your-subscription flow, so the path from the free tier to a paid plan is a single click, and the incentives below plug straight into real Stripe invoices.

Refer friends, earn perks. The headline growth loop is a referral program that rewards you for bringing people who stick. Share your code; when a friend you invited subscribes, you both benefit, and you start climbing. Your first qualifying referral earns you a month free; a second earns 25 percent off for three months; a third earns 50 percent off for six. Along the way you rank up, Bronze, Silver, Gold, Platinum, and at ten qualifying referrals you unlock the Ambassador tier. It is a game with real payouts, not a one-time coupon.

The Ambassador tier is the contract-based partnership at the top of that ladder, for the people who bring the most, and it is deliberately not a coupon giveaway:

• Real revenue share. Ambassadors sign a contract and earn 15 percent of net referee revenue, paid quarterly, computed straight from Stripe invoices minus processing fees.
• One-click enrollment. Signing up mints a public, multi-use promo code.
• A real back office. The admin panel tracks active ambassadors, pending payouts, lifetime paid and next-due dates, with a full roster and a candidates list that auto-qualifies anyone with ten or more qualifying referrals.
• Semi-automated payouts. A daily job computes commissions for closed windows and emails a heads-up when a payout is due; the wire itself stays a deliberate, manual admin action.

The content engine kept pace. Four long-form posts shipped in July, Security and Compliance at Melaya on 3 July, a 30-minute read, The Anti-Hallucination System on 7 July, Your AI Can Use a Phone Now on Device Control on 21 July, and the launch post Melaya Is Live on 22 July. That is more than 70 minutes of substantive reading in one month, plus the recap you are reading now. Under the hood, blog routes are prerendered with per-language sitemaps and hreflang tags, so search engines see real pages in every language we ship.

Now in eight languages. Melaya went from five product languages to eight this month, adding Hindi, Russian and Tagalog. This is not a thin UI translation: each new language ships the full surface, the app chrome, the marketing and legal pages, the tutorial tours, the in-app documentation, and the tool, connector and persona catalogs, so the product reads natively for three of the largest addressable user bases right as the doors opened.

And because we build agents for a living, marketing is becoming agent work too: there is now an agent playbook for generating nine-by-sixteen vertical videos, TikTok and Reels format, as tooling, ready to turn product moments into short-form content.

We are not publishing adoption numbers yet. The honest summary is simpler: the funnel is open, the incentives are wired to real revenue, and the content pipeline is running.

7. Breadth without sprawl: connectors, SDKs, AI providers

Let us be plain about where July's energy went, and where it did not. The trading engine is parked, the vertical is paused pending investor interest, and it has not materially changed since mid-June. The center of gravity was general-purpose agents, the phone, memory and connectors, and the breadth numbers reflect that.

The connector catalog now stands at 290 connectors, 98 of them keyless, public-API vendors that need no credential at all, usable the moment you select them. July's additions skew social and infrastructure: YouTube, Threads, Mastodon, Google Ads, Stripe and the full Cloudflare suite, alongside Telegram, Facebook, LinkedIn and Luma.

The bigger unlock is that Connectors in Chat is now complete. The assistant can use any selected connector's tools directly in conversation, cloud, local-runner or hybrid, via lazy discovery tools, with human approval gating every write. A small but satisfying fix landed too: the Google connector now correctly expands to both Gmail and Calendar.

The catalog totals tell the growth story without embellishment:

• 1,697 tools, up from 1,366 in June, a gain of 331.
• 111 agent personas.
• 23 AI providers, up from 21, Claude Code and Codex joined, both running local-runner only.
• Roughly 95 built-in starter pipeline templates, including Device-Control workflows.

On the SDK side, restraint was the feature. All nine official languages, TypeScript, Python, Go, Rust, Java, Kotlin, C#, Ruby and PHP, moved to v0.2.0 with no new languages added. Instead, July hardened what exists: Bearer-only credentials, the TLS-verify bypass removed, URL-credential handling fixed, and event authentication tightened. Those SDKs sit on a public REST surface of 154 developer routes spanning trading, agents and platform namespaces, the full platform, not a trading-only API.

That is the pattern we are aiming for: more connectors, more tools, more providers, but converging on one chat surface, one approval model and one hardened API, rather than sprawling into ten half-finished ones.

8. Documentation: learn the platform, then build on the API and SDKs

An open beta is only as good as how fast someone can go from curious to shipping, so July put the whole platform in writing. Full public documentation for building agents and for Device Control is now live, alongside a complete developer reference, and it is all public and inspectable.

• Product and how-to guides. Step-by-step documentation for the Agent Builder, the Assistant, Device Control, connectors, memory, evaluation and human-in-the-loop, the same corpus the Assistant retrieves from to answer your questions in-app.
• A function and tool reference. Every tool and function an agent can call is catalogued and searchable, so you can see exactly what an agent is able to do, and with which inputs, before you wire it into a workflow.
• The API and the SDKs. The full platform is exposed over a public REST API, 154 developer routes across the agents, platform and trading namespaces, with nine official SDKs, TypeScript, Python, Go, Rust, Java, Kotlin, C#, Ruby and PHP, at v0.2.0, so you can call Melaya's functions and build it into your own stack in the language you already use.

The point is that you never have to take our word for it. You can read how an agent is instructed, which functions it can call, and exactly which API endpoint or SDK method drives it. Learn the concept in the guides, look up the function in the reference, then call it from the API.

9. Partnerships: the doors open both ways

Open beta opened Melaya to users. July also began opening it to partners. We have started signing MOUs with integration partners, and the offer is straightforward: if you build AI agents, run commercial business development, or resell software into a book of clients, there is a generous reseller discount for putting Melaya in front of them. Distribution should reward the people who create it.

The invitation runs the other way too. If you are a technology provider, a data provider, or any API-callable service, we want to integrate you. Every connector we ship makes every agent more capable, so a good integration is a win for your users and ours at the same time. We would rather build the integrations people actually ask for than guess at a roadmap.

If any of that fits you, the door is [email protected]. Reseller, integration partner, data or API provider, tell us what you have and who you serve, and we will move quickly.

Where this leaves us

July was the shortest distance Melaya has ever traveled between an idea and a person using it. The waitlist is gone. An agent can open your phone, read the screen, and hand you the last decision. The assistant remembers what you told it an hour and a redeploy ago. And every consequential action still stops at the point it would happen, waiting for a human, because that is the only version of agent autonomy we think is worth shipping.

We opened the doors this month. August is about the people who walk through them: sharper onboarding, deeper playbooks for the apps you actually use, and the first honest numbers once they mean something. If you want to see an agent finish a real job, and stop exactly where you would want it to, start at melaya.org. It is free.

A note on the figures in this recap. The 185 commits and 1,141 files-touched are activity indicators and include machine-generated catalog and localization artifacts, not hand-authored files. Catalog counts are as of 30 July 2026. We do not publish adoption, traffic or revenue numbers we cannot yet stand behind, and we would rather tell you what shipped than imply how it performed.

Frequently asked questions