In today’s newsletter:

• ROMA: Meta-agent framework for building high-performance multi-agent systems

• Hands-On: Make Gemini CLI and Claude Code 10× More Powerful

Reading time: 3 minutes.

Recursive Open Meta-Agents (ROMA)

ROMA is an open-source meta-agent framework for building agents with hierarchical task execution.

It adopts a recursive hierarchical architecture where tasks are decomposed into subtasks, agents handle the subtasks, and results are aggregated upward.

The goal is to simplify the development of complex agent workflows by making task decomposition, coordination, and tracing more manageable.

Key components:

• Atomizer: Determines whether a task is “atomic” (directly executable) or requires planning.

• Planner: Breaks down non-atomic tasks into subtasks.

• Executor: Executes atomic tasks using LLMs, APIs, or even other agents.

• Aggregator: Collects results from subtasks and merges them into a parent output.

The recursion loop follows: solve(task) → decompose → solve(subtasks) → aggregate results.

It's 100% open source.

🔗 Link to the Github Repo

Make Coding Agents more powerful with persistent memory

Coding agents have a fundamental limitation. They forget everything between sessions. Project conventions, past fixes, and design decisions all disappear once the session ends.

Without memory, agents can only react to the current prompt. What’s missing is a way to persist and reuse project context across sessions.

This is where ByteRover comes in. ByteRover provides a persistent context layer that coding agents can query when they start a new session, instead of relying on chat history.

In this walkthrough, we use ByteRover with Gemini CLI, though the same workflow applies to other coding agents.

Let’s get started!

Step 1: Install and initialize ByteRover

Install the ByteRover CLI, navigate to your project, and start ByteRover.

Step 2: Login and Initialize

Next, In the ByteRover Console, run /login to authenticate via browser.

Then run /init to set up your project by selecting your team, space, and coding agent.

ByteRover syncs your remote context and generates the required rule files.

Step 3: Curate project context

Once ByteRover is initialized, the next step is to capture project knowledge that the agent should remember.

Context can be scoped to a specific part of the codebase, such as unit testing conventions, API design rules, folder structure, or deployment patterns. This keeps the memory focused and useful, instead of dumping the entire repository.

In this example, we use Gemini CLI as the coding agent, but the same flow applies regardless of the agent you’re using. You prompt the agent to run brv curate with a clear instruction, for example to document the project’s unit testing strategy.

ByteRover then analyzes the relevant files and extracts patterns, conventions, and structure related to that area. The captured context is stored locally with the project and can be reused in future sessions.

Step 4: Verify and query context

After curation, use the status command to review what ByteRover captured. This confirms that the expected rules, patterns, and files are stored and ready to use.

To verify persistence, start a new session with no prior chat history. Then ask the agent to use brv query to retrieve the specific context needed for the task, for example the project’s unit testing rules or architectural conventions. ByteRover injects this context before code generation, so the agent follows existing project patterns instead of starting from scratch.

Step 5: Share context with the team

After curating context locally, open the ByteRover Console by running brv.

From the console, run /push to upload your local context to the remote workspace. This syncs the curated rules, patterns, and project knowledge to a shared space.

At this point, you should see the updated context reflected in the remote workspace (shown in the image below), confirming the push was successful.

Teammates can then run brv, open the console, and use /pull to bring that context into their own local projects beforestarting work. Their coding agents now operate with the same project rules and conventions from the start.

This keeps everyone aligned on a single source of truth, without re-explaining decisions or duplicating setup across people or sessions.

Why This Matters

Coding agents are only as useful as the context they operate with. Without a way to persist project knowledge, every agent behaves like it is seeing the codebase for the first time, no matter how capable the model is.

In this walkthrough, we used Gemini CLI, but the problem and the approach are not specific to one tool.

Whether you are using Cursor, Claude Code, or any other coding agent, the need is the same: project context should live outside the chat session and carry forward over time.

​You can checkout ByteRover here →​

That’s all for today. Thank you for reading today’s edition. See you in the next issue with more AI Engineering insights.

PS: We curate this AI Engineering content for free, and your support means everything. If you find value in what you read, consider sharing it with a friend or two.

Your feedback is valuable: If there’s a topic you’re stuck on or curious about, reply to this email. We’re building this for you, and your feedback helps shape what we send.

WORK WITH US

Looking to promote your company, product, or service to 160K+ AI developers? Get in touch today by replying to this email.