Today4 stories

The Daily Org

Spring '27Sandboxes 6 Feb 2027

Curated by Abhinav (opens in a new tab)

Vol. I · No. 21The independent daily for Salesforce admins, developers and architects4 stories

Must-readDevOps

Running Apex tests locally so AI coding agents can iterate on them (opens in a new tab)

You will learn why coding agents stall on Apex when every test run needs a Salesforce org, and how a local Apex runtime exposed through an MCP server gives an agent a fast write-run-fix loop.

Why read this

You will also see the boundary the article draws around deployment.

Against an org

  • Deploy class to an org
  • Wait, then start test run
  • Poll until finished
  • Minutes per cycle

Against a local runtime

  • Run tests on the machine
  • Read structured results
  • Fix and rerun
  • Seconds per cycle
Agent loop against a Salesforce org versus against a local Apex runtime

The article argues that AI coding agents stall on Salesforce Apex because Apex only runs inside a Salesforce org, so each test cycle means deploying, waiting, polling and parsing logs, which can take minutes and requires org credentials. Agents then either stop iterating and hand back untested code, or keep going at a high cost in time and tokens. The author’s published benchmark puts four open-source Apex suites, 837 tests in total, at about 1 minute 46 seconds to deploy and run in an org, against 2.4 seconds locally. The piece also notes that Nimbus was renamed renmy runtime in October 2026, with the same binary and the MCP server name nimbus kept.

The proposed fix is renmy runtime, a local Apex runtime that executes classes, triggers, SOQL, DML and Salesforce Flows against an embedded PostgreSQL, with no org, sandbox, Docker or JVM. The author says it enforces governor limits and mirrors platform behaviour such as Test.startTest and Test.stopTest, and that it is not a mock or a transpiler, though it does not achieve perfect parity. Its renmy mcp command runs as a stdio child process of the agent, so no port or credential is needed. The exposed tools include run_apex_tests, explain_failure, get_coverage, get_execution_trace, execute_anonymous and list_test_classes, which return structured results rather than logs to parse. Setup is a one-line install, a test run in the project, and registration with Claude Code, Cursor or GitHub Copilot.

A worked example shows an agent adding a discount rule to an invoice service: it lists existing tests, writes a method and test, runs the suite, uses the failure explanation to find a status filter bug, fixes it, and uses coverage to add a boundary test, all within seconds and without touching an org. The author also connects this to Salesforce Headless 360, where Apex hooks such as InvocableMethod and RestResource become tools for Agentforce or external agents, and says the runtime can test that underlying Apex offline.

The article draws a firm boundary around deployment. A green local run is necessary but not sufficient, because the org holds Permission Sets, managed packages, Validation Rules and other teams’ automation that a repository does not contain. The agent should not deploy on its own. renmy deploy runs local gates, then a real check-only validation in the org before deploying, while renmy release validate and renmy release deploy add a human approval step and an immutable receipt between the two. The Free tier covers unlimited local test runs, and the MCP server is a Pro feature that is free during the public beta.

Read the original at dev.to (opens in a new tab)

Worth reading?

RecommendedDevOps

Running Apex tests on a local runtime, without an Org round trip (opens in a new tab)

You will learn what renmy runtime does, how it runs Apex and Flows locally against an embedded PostgreSQL, and which commands cover testing, debugging, AI agent integration and gated deploys.

Why read this

You will also see what the benchmark claims and what sits behind the Pro tier.

  1. Snapshot selected source into a bundle
  2. Run local validation and test gates
  3. Check-only validation in the target org
  4. Deploy the validated bundle
The gated deploy path from local source to the Salesforce org

Nimbus has been renamed renmy runtime, with the same tool and the same binary. It is a local Salesforce Apex runtime that executes real Apex, SOQL, DML and Salesforce Flows on a developer’s machine against an embedded PostgreSQL database. The runtime enforces platform rules such as governor limits, order of execution across triggers and flows, and per-test transaction isolation. It ships as a single binary for macOS, Linux and Windows and needs no org, Scratch Org, Docker or JVM.

The article’s benchmark compares four open-source Apex suites containing 837 tests. Run in a Salesforce org, they took about 1 minute 46 seconds, and locally they took about 2.4 seconds, roughly 45 times faster, with every test passing in both places. Around the runtime sit a language server that serves editors such as VS Code, Cursor, Neovim, Zed and JetBrains IDEs, a live debugger that supports breakpoints and stepping, and line and branch coverage reporting. Pro adds mutation testing, which the author says is the first of its kind for Apex, and watch mode. The toolkit also includes failure explanation and triage tools, a browser-based Dev UI, and a flaky-test finder.

For AI coding agents, renmy provides an MCP server with tools for running tests, executing anonymous Apex, reading coverage and explaining failures, so agents can verify Apex locally before anything reaches an org. The deployment path is gated: renmy deploy is free and snapshots the source, runs local tests and coverage gates, validates the same bytes in the target org with a check-only validation, and then deploys. The Pro renmy release commands split validation from deployment and produce a receipt that records the bundle digest, Git revision, gate results and the validation job ID, so a team can approve and deploy the validated payload from another machine. The article stresses that Sandboxes remain useful for end-to-end checks and user-facing testing.

The Free tier costs nothing without a card and covers unlimited local test runs, gated deploys, Salesforce CLI pass-through and IDE integrations on one machine. Pro, which adds the daemon, parallel runs, debugger stepping, mutation testing and the MCP server across three machines, and Team are both free during the public beta. Their list prices are $19 per month and $49 per developer per month, and Enterprise starts at $20,000 per year.

Read the original at dev.to (opens in a new tab)

Worth reading?

DevOps

Four rules for constraining an AI agent that deploys to Salesforce (opens in a new tab)

You will learn a design for letting an AI agent handle Salesforce deploys safely: a fixed action menu, approval gates, org-checked results and logged, capped runs.

Why read this

The reader comes away with a concrete set of guardrails to consider.

  1. Plan reviewed and approved
  2. Check-only validation in production
  3. Human clicks to deploy
  4. Org queried to verify results
The agent works through three human approval gates before production changes

The author argues that the slow part of a Salesforce deploy is usually assembling the package, choosing tests and target org, and interpreting failures, which are language tasks suited to a model. Deployment itself is not, so the agent is designed around four rules.

First, the model never touches an org. It receives no credentials, shell or sf CLI access, only a fixed menu of actions such as validate, deploy, run tests, query and retrieve. Code checks its parameters and performs the action with the sf CLI and git.

Second, humans approve at three points: the plan, which shows components, target org, tests and risk; a changed plan, when a retry alters components or scope; and production, where a check-only validation runs before a human deploys, including destructive changes. Sandbox steps run automatically while everything stays green. Third, success is verified by querying the org, not taken from the model, and the summary is written from that evidence table. Fourth, every run is logged, with a cost cap and a limit of three retries.

The model’s role is limited to turning a request into a reviewable plan and turning a failed deploy into a plain explanation, such as a test that does not set a new checkbox and so trips a new Validation Rule.

Read the original at dev.to (opens in a new tab)

Worth reading?

Flow and admin

Handling Flow errors with Fault paths, logging and notifications (opens in a new tab)

You will learn why a Flow can fail without anyone noticing, and five practices for using Fault Paths to log, notify and test failures.

Why read this

The advice is standard but practical for admins maintaining automation.

  1. Data element fails
  2. Fault Path runs
  3. Log failure record
  4. Notify admin or owner
How a failed Flow element is handled once a Fault Path is in place

A Fault Path is the branch a Flow takes when one of its elements fails, such as a record update blocked by a Validation Rule, a create that trips a duplicate rule, or a lookup that returns nothing. Without one, a Screen Flow shows the user a generic error, while a Record-Triggered Flow rolls back quietly and tells no one. The author argues that failures are easy to miss for this reason and that a missing branch is usually the cause.

The article gives five practices. Add a Fault Path to every data element, since failures often come from changes made elsewhere, such as a new Validation Rule or a permission change. Log each failure to a Custom Object, capturing the Flow name, element, record ID and the $Flow.FaultMessage value. Pair the log with a notification to an admin group or record owner so failures are seen the same day. Decide for each Flow whether a failure should stop the process or let it continue and flag the record for follow-up. Finally, test the failure paths in Flow Builder’s debug mode by feeding in data that violates a rule before each deployment.

The author also notes that a Flow can fail for different reasons depending on whether it runs in system or user context, because of Sharing Rules, field-level security or missing permissions. If a Flow fails only for some users, the run context should be checked first.

Read the original at dev.to (opens in a new tab)

Worth reading?