6 indie AI agent drops from Aug 3–7: multi-agent harnesses, memory, and learning mode (2026)

Six public drops qualified for this week’s scan, covering August 3–7, 2026 in Africa/Lagos. I kept builds with a public artifact and a first-party launch, repository, product page, or post; funding-only news and big-lab flagship announcements are out.

The useful pattern is not a new model release. It is the layer around the model: how to run several agents without collisions, make their output readable, give them memory, keep the human learning, and test whether cooperation actually works.

Drop	What shipped	Why it is worth a look
HAR	An open-source harness for parallel coding agents	Isolated worktrees, repeatable verification, and proof for each run
Mirafold	A solo builder’s browser UI for terminal agents	Turns agent scrollback into live cards, charts, tasks, and diffs
Remembrane	Local agent memory in one SQLite file	Deterministic, explainable recall that can be tested in CI
Learning Mode	A behavioral skill for coding agents	Makes the agent teach while you build instead of hiding the work
Modality	An open verification language for agent cooperation	Gives commitments, logs, and temporal rules a formal shape
CoArena	A blind, community-run arena for browser tasks	Compares computer-use agents on tasks people can watch and judge

HAR puts a factory around parallel coding agents

What shipped. HAR launched on Product Hunt on August 7 as an open-source, agent-agnostic framework for multi-agent coding workflows. Its repository describes a CLI and MCP server that give each agent an isolated worktree, ports, and—when needed—a separate database. A shared .har/ contract tells Claude Code, Cursor, Codex, or another MCP client how to discover, launch, verify, and tear down a run. 1 2

The interesting part is the verification trail. HAR records logs, artifacts, and a validated tree hash so a reviewer can inspect what actually ran instead of accepting the agent’s summary. It also ships a local Mission Control dashboard and an open plugin system. 2

Why it matters. Running one coding agent is mostly a prompt-and-terminal problem. Running five is an environment problem: shared ports, dirty git state, conflicting databases, and unclear handoffs. HAR treats those as infrastructure. Its bet is that a coding agent should receive a project contract and return code plus evidence, not just a patch.

Try it. The repository’s quick start is npm install -g @osfactory/har, followed by har env init, har env launch 1, and har env verify 1 --full. Start with a small repository and inspect the generated proof before putting a fleet on a consequential codebase. 2

Mirafold makes the terminal agent look like a product

What shipped. Solo builder kserrec posted Mirafold to Hacker News on August 7 as a public-beta browser interface for Codex, Claude Code, and Gemini CLI. The project keeps the underlying agent and its permissions, but renders its output as cards, tables, charts, task lists, diffs, and sandboxed interactive views instead of one long wall of scrollback. 3 4

The product is unusually specific about what stays local. The daemon runs on the user’s machine, API keys stay there, and the open-source MIT product can point at local inference servers such as Ollama, LM Studio, or vLLM. A real PTY handles interactive commands such as sudo and ssh; a separate trusted shell keeps credentials and the prompt box away from agent-rendered content. 4

Why it matters. This is an interface-layer experiment, not another coding agent. The agent can already produce a diff or a test log; Mirafold asks whether those outputs should be presented as a live workspace that a human can inspect and steer. The second-order idea is that a useful agent UI may need to be generated by the agent itself, while the security-sensitive shell remains outside its reach.

Try it. Install with npm i -g mirafold, run it inside a project, and compare the same task with the terminal client. The source repository is linked from the project’s own page. 4

The caveat is simple: this is a fast-moving public beta. The polished view does not change the underlying agent’s ability to make mistakes, and the hosted phone relay is a paid convenience rather than a requirement for the local product. 4

Remembrane treats memory as a file, not a service

What shipped. Remembrane appeared on Hacker News on August 7 as a small Python library for persistent agent memory. Its design is deliberately narrow: one SQLite file, no required dependencies, deterministic recall, and a journal that lets a user inspect how memory changed. The repository adds hybrid vector-and-BM25 retrieval, explainable score breakdowns, time-travel queries, conflict detection, context packing, an MCP server, and adapters for LangChain and CrewAI. 5 6

That combination makes it more useful than a generic “memory layer” description. You can copy, back up, diff, or delete the database. You can freeze time in a test and assert what the agent should recall. When two stored facts conflict, the library surfaces the tension as a candidate for adjudication instead of silently choosing one. 6

Why it matters. Hosted memory is convenient but hard to audit. A local file gives a solo builder a concrete artifact: it can live beside the project, travel with a deployment, and enter the same test loop as the code. That is a better fit for personal agents and small tools where “a few thousand facts” is the actual scale.

Try it. The shortest route is pip install remembrane, then create a MemoryStore("agent.db") and call store() and recall(). The README includes MCP setup for Claude Desktop or Claude Code and examples for conflict review. 6

The author is clear about the boundary: the default embedder is lexical rather than semantic, and the project is aimed at agent-scale stores, not millions of records. The CrewAI integration is currently a helper rather than a drop-in storage backend. Those limits make the project easier to evaluate, not less interesting. 5

Learning Mode turns coding help into practice

What shipped. The Agentic AI Foundation shared Learning Mode on X on August 7, pointing to Dakota Fabro’s open repository. It is a behavioral skill, not a new model or autonomous runtime: the agent shifts from “do it for you” to “do it with you,” asking what the user would try, giving smaller challenges, and reducing scaffolding as the user improves. 7 8

The skill defines four growth tiers—Orientation, Judgment, Execution, and Multiplication—and a Depth of Knowledge scale from 1 to 4. It supports a feature-build mode and a PR-review mode, with checkpoints for understanding the task, connecting concepts, reasoning through decisions, and explaining what was learned. The repository says it works with Goose, Claude Code, Cursor, Codex, Amp, Gemini CLI, Claude Desktop, and other agents that read Markdown instructions. 8

Why it matters. “The agent finished it” and “I can do this now” are different outcomes. Learning Mode makes that difference explicit. It is a practical answer to the most common failure mode of AI-assisted coding: a working feature whose owner cannot explain the choices inside it.

Try it. Install the skill globally with npx skills add dakotafabro/learning-mode -g. It works without configuration; a DOK tracker is optional if you want the agent to calibrate across sessions. 8

The trade-off is time. A system that pauses to ask questions will lose to autocomplete on raw time-to-merge. That is the point of the project: it optimizes for capability gained, not just code produced.

Modality gives agent cooperation a contract language

What shipped. The Modality account posted on X on August 7 that its open-source project is building a verification language for trustworthy agent cooperation. The linked repository describes Modality as a language for agents and humans to negotiate and verify cooperation through formal verification: modal contracts are append-only logs of signed commits, with commitments expressed through temporal logic. 9 10

The project’s stated use cases include escrow, swaps, and milestones. It has JavaScript libraries for web use and Rust libraries and a CLI, with documentation for agents as well as human developers. 10

Why it matters. Multi-agent systems often rely on a prompt saying “do X, then wait for Y.” Modality tries to move that promise into explicit state, signed history, and rules that can be checked. That does not make an agent honest; it makes the agreement inspectable and gives a runtime something more precise to enforce.

Try it. The repository links the getting-started documentation and gives a one-line installer: curl --proto '=https' --tlsv1.2 -sSf https://www.modality.org/install.sh | sh. Read the contract examples before treating it as production infrastructure. 10

CoArena tests computer-use agents with a human in the loop

What shipped. CoArena’s creator said on Hacker News that an earlier computer-use agent reached second place in a large benchmark, then argued that existing benchmarks did not capture how tasks were completed. The new site puts two hidden models side by side on a real browser task and asks a person to vote for the better result—or for neither. 11 12

The site exposes live tasks and a leaderboard, while the creator’s post says the model identities are hidden until after the vote. The early project claims a difference between success and speed in its initial results, but it is still asking the community to supply more tasks and feedback. 11

Why it matters. Computer-use agents fail in ways that a final screenshot hides: extra clicks, slow recovery, fragile navigation, or an action that technically completes the task but is painful to watch. A blind side-by-side test lets people judge the whole interaction. It is closer to product evaluation than a static benchmark score.

Try it. Post a browser task on coarena.ai and judge the live pair. Treat the leaderboard as an early community experiment, not a settled ranking: task selection and voter preference will shape it heavily. 12

The thread tying the drops together

HAR and Mirafold work on execution: one isolates and verifies agent runs, the other makes them legible and steerable. Remembrane and Learning Mode work on continuity: one preserves machine context, the other preserves human understanding. Modality and CoArena work on trust: one formalizes commitments, the other makes performance visible to a judge.

That is a useful map for the week. Independent builders are not trying to outspend frontier labs on model training. They are filling the gaps that appear after a model can already call tools: state management, interfaces, memory, evaluation, and proof. If you are choosing what to try, match the tool to the bottleneck: parallel execution points to HAR, agent UI to Mirafold, persistent context to Remembrane, learning to Learning Mode, cooperation rules to Modality, and computer-use evaluation to CoArena.