Which repository should I try first?

Start with the bottleneck you already have. Paperclip is useful for task ownership and budgets, Orca or T3 Code for controlling several coding agents, Open Code Review for pull-request review, and SkillSpector before installing unfamiliar agent skills.

Are Buzz, Paperclip, Orca, and Hermes competitors?

Only partly. Buzz is a shared communication workspace, Paperclip is a control plane, Orca is a parallel coding cockpit, and Hermes is a persistent agent runtime. A team could use more than one, but should add layers only when each solves a measured problem.

Is it safe to copy my browser profile into ego-lite?

Treat browser state as a credential. Use a dedicated test profile with low-value accounts, revoke sessions after experiments, and never migrate a primary browser profile containing banking, admin, health, or production access.

Can an AI code reviewer replace tests and human review?

No. Open Code Review combines deterministic checks with LLM analysis, but it can still miss defects or raise false positives. Keep CI, tests, protected branches, and human approval for consequential changes.

Can I redistribute a skill made from any book?

Not automatically. Book-to-Skill is MIT licensed, but the source book keeps its own copyright. The project explicitly warns users not to redistribute generated skills based on copyrighted books without permission.

Does open source mean free to operate?

No. Repository access can be free while models, hosting, APIs, storage, observability, and engineering time still cost money. Also check each license, provider terms, and any enterprise-only folders before adopting a tool.

What is missing from most multi-agent stacks?

Evaluation, observability, permissions, and rollback. Promptfoo, Langfuse, SkillSpector, isolated worktrees, and explicit approval gates make a more complete operating layer than a collection of agent interfaces alone.

GitHub Agent Stack: 13 Repositories for Chat, Tasks, Browsers, Reviews, and Coding

Direct Answer

This week's useful GitHub story is not one winning repository. It is an emerging agent operating stack: Buzz supplies shared conversation, Paperclip governs tasks and budgets, Orca and T3 Code supervise coding work, Hermes runs persistent agents, ego-lite gives agents browser sessions, Open Code Review checks pull requests, and skills encode repeatable behavior.

The right adoption order is one bottleneck, one repository, one restricted pilot. Do not install thirteen projects and call it an agent company. Pick a layer, define a pass/fail test, restrict permissions, measure accepted output, and only then add another component.

Your bottleneck	Start here	Measure this
Agents lose context across chats	Buzz	Useful decisions recovered without re-explaining the project
No task ownership or cost visibility	Paperclip	Tasks finished within budget and with an auditable approval trail
One coding agent blocks all other work	Orca or T3 Code	Accepted pull requests per reviewer-hour
Need an always-on agent runtime	Hermes Agent	Successful scheduled runs without unsafe intervention
Agents repeatedly lose browser sessions	ego-lite	Completed browser flows using a restricted test profile
Pull requests need a second opinion	Open Code Review	True defects found, false-positive rate, and review time saved
Prompts and methods are inconsistent	Matt Pocock Skills or Book-to-Skill	Repeatability across tasks and operators
No evidence that the agent improved	Promptfoo plus Langfuse	Eval score, failure classes, latency, and cost over time

Watch the GitHub Roundup

Episode credit: Andrew Warner and Matt Van Horn for The Next New Thing. Watch the original video. The episode includes a Zapier MCP sponsorship; commercial services are labeled separately below.

The show's 31 July companion page supplied the repository list, supporting videos, and social posts. This guide checks those links against the projects' own documentation and adds licensing, permissions, adoption guidance, and a missing safety layer.

The Stack Map

Layer	Repositories	Question it answers
Shared workspace	Buzz	Where do humans and agents communicate with durable context?
Governance	Paperclip	Who owns each task, what may it cost, and who approved the result?
Coding control	Orca, T3 Code, JCode	How do we launch, isolate, resume, and supervise implementation work?
Persistent runtime	Hermes Agent	What keeps an agent available across sessions and schedules?
Browser state	ego-lite	How does an agent use authenticated web applications?
Quality	Open Code Review	How do we review code with deterministic and model-based checks?
Reusable behavior	I Have ADHD, Book-to-Skill, Matt Pocock Skills	How do we make instructions portable and repeatable?
Domain applications	Pascal Editor, World Monitor	What do agent-ready tools look like beyond a generic chat box?

Important: these layers are composable, not mandatory. A solo developer may need only T3 Code and protected Git branches. A larger agent operation may need Paperclip, a runtime, observability, evaluations, and separate approval gates.

The 13-Repository Directory

1. Buzz

Job: Shared chat and projects where humans and agents are first-class members.

License: Apache-2.0. Practical verdict: Promising early workspace. Pilot with a small team; mobile, huddles, and approval flows are still maturing.

Watch: Self-hosting does not remove the need to secure identities, relays, repositories, and agent permissions.

2. Paperclip

Job: Control plane for goals, agent assignments, budgets, approvals, costs, and audit history.

License: MIT. Practical verdict: One of the clearest governance layers in the list, especially when agent work already spans several tools.

Watch: Its quickstart trusts local loopback. Enable authenticated deployment before exposing it beyond your machine; review optional telemetry.

3. Orca

Job: Parallel coding-agent cockpit with one worktree per feature, Git controls, SSH, and mobile access.

License: MIT. Practical verdict: Best fit when the bottleneck is supervising several isolated implementation attempts at once.

Watch: Parallel output multiplies review load. Confirm each model provider permits the way you connect subscriptions or credentials.

4. Hermes Agent

Job: Persistent general agent runtime with memory, tools, messaging, and scheduled or always-on work.

License: MIT. Practical verdict: A serious runtime rather than another chat skin. Useful for builders ready to own deployment and permissions.

Watch: Persistence plus broad tools creates a large blast radius. Start with read-only integrations and a disposable environment.

5. ego-lite

Job: Browser spaces for agents, including migration of Chrome logins, cookies, extensions, and bookmarks.

License: MIT repository; separate browser application. Practical verdict: A practical answer to repeated agent logins, but credentials are the product and the risk.

Watch: Never import a primary profile first. Use a dedicated agent profile with low-privilege accounts and revocable sessions.

6. Open Code Review

Job: Hybrid pull-request review combining deterministic static rules with LLM analysis.

License: Apache-2.0. Practical verdict: Useful as a second reviewer because it mixes conventional checks with semantic analysis.

Watch: Treat findings as evidence to inspect, not merge authority. Keep tests, branch protection, and human approval.

7. I Have ADHD

Job: An action-first output skill that makes long agent responses shorter and easier to scan.

License: MIT. Practical verdict: Tiny, understandable, and immediately useful for anyone who prefers direct next actions.

Watch: It is a communication preference, not a medical tool or accessibility certification.

8. Pascal Editor

Job: Browser-based 3D building and spatial editor built with React Three Fiber and WebGPU.

License: MIT. Practical verdict: A strong domain example of agent-assisted work moving beyond text and conventional web apps.

Watch: Check WebGPU support and project maturity before relying on it for production architecture work.

9. Book-to-Skill

Job: Transforms source material into a reusable agent skill and supporting reference structure.

License: MIT converter; source rights remain separate. Practical verdict: Useful for personal knowledge workflows and authorized material, with a clear copyright boundary.

Watch: Do not publish or sell transformed copyrighted books unless the rights allow it.

10. JCode

Job: Lightweight Rust coding agent with provider choice, browser tools, sessions, and OAuth flows.

License: MIT. Practical verdict: Interesting terminal-first option when startup speed and model flexibility matter.

Watch: The headline speed number is project-reported. Benchmark accepted work, not launch time alone.

11. Matt Pocock Skills

Job: Composable development skills for planning, research, debugging, review, and challenge workflows.

License: MIT. Practical verdict: A useful library to study selectively instead of installing every instruction indiscriminately.

Watch: Read each skill before enabling it and adapt assumptions to your repository and review policy.

12. T3 Code

Job: Desktop, web, and mobile control surface for local coding agents and several model harnesses.

License: MIT. Practical verdict: A polished operator interface for people who want to supervise local agents away from the terminal.

Watch: A control surface inherits every permission and subscription risk of the agents beneath it.

13. World Monitor

Job: Global OSINT, maps, feeds, local AI, APIs, desktop packaging, and MCP access.

License: AGPL-3.0-only. Practical verdict: A rich monitoring surface and a good reference for agent-accessible domain applications.

Watch: It aggregates sources; it does not turn every source into verified intelligence. The AGPL license matters for network deployments.

Team, Control, and Execution Layers

Buzz is the room, not the manager

Buzz is an Apache-2.0 workspace from Block where agent identities, human identities, shared rooms, Git activity, and workflows can live together. Its open protocol and self-hostable relay are the strategic difference from a conventional chat integration. The project is still an early preview, so use it to learn the interaction model before treating it as a Slack replacement for a regulated team.

Paperclip is the management ledger

Paperclip explicitly describes itself as a control plane, not a chatbot, agent framework, workflow builder, or code reviewer. Its goals, org chart, heartbeats, budgets, approvals, cost tracking, and immutable audit log answer the operational questions that agent demos usually skip. The local quickstart trusts loopback traffic; broader deployment needs authentication and a telemetry decision.

Orca and T3 Code solve the operator interface

Orca isolates parallel coding work in separate worktrees and exposes terminals, Git state, GitHub integration, SSH, and mobile controls. T3 Code offers a more productized desktop, web, and mobile control surface across Codex, Claude, Cursor, Grok Build, and OpenCode. Both can improve throughput, but only if review capacity grows with generation capacity.

Hermes and JCode answer different runtime questions

Hermes Agent is a persistent, tool-using runtime designed for memory, messaging, and scheduled work. JCode is a lightweight Rust coding agent emphasizing startup speed, provider choice, browser tools, and resumable sessions. One is closer to an always-on employee runtime; the other is a fast terminal worker.

Browser Access and Code Review

ego-lite removes login friction by moving sensitive state

ego-lite can migrate Chrome data such as cookies, logins, extensions, and bookmarks into agent browser spaces. That is useful because authenticated browser work is where many agents fail. It is also why the pilot must begin with a dedicated browser profile, test accounts, minimal permissions, short-lived sessions, and a revocation plan.

Credential rule: never give an experimental agent browser your everyday Chrome profile. Browser cookies can be equivalent to passwords and may bypass the protections you expect at login.

Open Code Review adds a second reviewer, not a merge button

Alibaba's Open Code Review combines deterministic rules for problems such as null handling, thread safety, XSS, and SQL injection with LLM-based analysis through OpenAI- and Anthropic-compatible APIs. That hybrid design is more credible than asking a model to freely improvise a review. Still, benchmark it against defects your team already understands and keep humans responsible for merges.

Andrew and Matt also mention Greptile, a commercial AI code-review product, and the open Compound Engineering plugin. They are useful comparison points: one is a managed reviewer, while the other shows how planning, implementation, review, and learning can be encoded as a repeatable development method.

Skills and Domain Tools

I Have ADHD is intentionally small: it tells the agent to lead with actions, use numbered steps, remove preambles, and keep output scannable. Its value is not medical; it is proof that a compact communication contract can be more useful than another model switch.

Book-to-Skill turns source material into reusable agent instructions and references. Use it for your own writing, public-domain books, licensed material, or private study. The converter's MIT license does not erase the copyright of the input, and the project warns against redistributing skills made from copyrighted books.

Matt Pocock's skills are a broader development library, including planning, debugging, research, review, and adversarial challenge patterns. Read and install selectively. A skill is executable context: it can shape tools, permissions, and decisions, so it deserves the same review discipline as code.

Pascal Editor and World Monitor are the domain examples. Pascal brings 3D spatial editing into the browser; World Monitor combines maps, feeds, OSINT sources, local AI, APIs, and MCP. Both are valuable because they expose structured tools an agent can operate. Neither turns generated geometry or aggregated intelligence into a verified professional conclusion by itself.

Supporting Video Library

These are the seven supporting videos collected by the companion resource page. They are demonstrations and creator opinions, not independent security audits. Sponsored material is labeled where the source identifies it.

Buzz workspace walkthrough

Video credit: Andrew Warner and Vinny Canger. Open on YouTube.

ego-lite browser automation tutorial

Video credit: Dan - Smart Tutorials (sponsored demo). Open on YouTube.

Alibaba Open Code Review overview

Video credit: Signal Coders. Open on YouTube.

JCode test and setup

Video credit: AICodeKing. Open on YouTube.

Matt Pocock skills workflow

Video credit: Matt Pocock. Open on YouTube.

T3 Code review

Video credit: Better Stack. Open on YouTube.

World Monitor setup and tour

Video credit: NLR Crew. Open on YouTube.

Creator Notes and Launch Threads on X

Social posts are useful for release context and demos, but repositories and documentation remain the source of truth for installation, licensing, and current behavior.

Follow the episode hosts: Andrew Warner and Matt Van Horn.

Supporting Services Mentioned

Tool	Role	Important note
Zapier MCP	Connect agents to business applications through managed actions.	Commercial sponsor in the episode. Scope each connected action and keep approvals for consequential writes.
Greptile	Managed AI pull-request review.	Commercial alternative to self-hosted review infrastructure.
Agent Cookie	Move authenticated browser state between agent machines.	High-risk credential operation. Use test accounts and inspect exactly what is copied.
Compound Engineering	Structured planning, execution, review, and learning workflows.	Good reference for skill architecture even if you do not install the full plugin.

Four Starter Stacks

Use case	Start with	Add later	Approval boundary
Solo software builder	T3 Code or Orca + Git worktrees	Open Code Review + Promptfoo	Human reviews every merge and deployment
Small agent-native team	Buzz + Paperclip	Hermes + Langfuse	Humans approve budgets, external messages, and production writes
Browser operations	ego-lite with a dedicated profile	Webwright + an MCP connector	Human approves purchases, account changes, and publishing
Reusable knowledge workflows	Matt Pocock Skills or Book-to-Skill	SkillSpector + Compound Engineering	Review source rights, instructions, and tool permissions before use

Six More Repositories Worth Adding

The roundup is strong on interfaces and execution. The additions below strengthen security, evaluation, observability, reproducibility, and baseline comparisons.

Repository	Why add it	License note
NVIDIA SkillSpector	Scan agent skills for suspicious instructions and risky behavior before installation.	Apache-2.0
Promptfoo	Build repeatable model, prompt, and red-team evaluations instead of relying on a single demo.	MIT
Langfuse	Trace agent runs, inspect latency and cost, and connect production behavior to evaluations.	MIT core; inspect enterprise folders
Microsoft Webwright	Have a browser agent produce rerunnable Playwright scripts and inspectable artifacts.	MIT
OpenCode	Use a provider-flexible terminal coding agent as a baseline or runtime beneath other interfaces.	MIT
OpenHands	Study a mature software-agent platform with sandboxing, integrations, and a large contributor base.	MIT core; enterprise code differs

One repo I would not start a new stack around: the official Vibe Kanban repository says the project is sunsetting. Popularity and old stars are not a maintenance guarantee; always inspect the current README, releases, issues, and license before adoption.

A Responsible Adoption Checklist

Write one real task and the measurable result you expect.
Read the README, license, recent releases, open issues, and maintenance status.
Inspect install scripts, requested credentials, telemetry, network calls, and default ports.
Run the first test in a disposable repository, browser profile, or sandbox.
Grant read-only access first and add write permissions one action at a time.
Keep secrets in a manager or environment store, never in prompts or repository files.
Define the actions that always require human approval.
Add an eval with known pass and fail cases before expanding autonomy.
Record cost, latency, failure rate, accepted output, and reviewer time.
Document rollback and credential revocation before a production pilot.

Episode Chapters

Time	Topic
00:00	GitHub roundup: this week's biggest AI and developer repositories
00:36	Buzz: a Slack-style workspace for agents and humans
05:33	Paperclip: assign, monitor, and govern agent tasks
06:36	Orca: parallel coding agents from one interface
08:33	Hermes Agent: persistent workflows and agent coordination
10:30	ego-lite: browser sessions and shared logins
13:03	Open Code Review: Alibaba's pull-request reviewer
16:21	I Have ADHD: more scannable agent responses
18:00	Pascal Editor: browser-based 3D building design
21:45	Book-to-Skill: turn books into reusable workflows
24:45	JCode: a lightweight terminal coding agent
27:00	Matt Pocock Skills for Claude and Codex
31:30	T3 Code: local and mobile coding-agent control
34:39	World Monitor: AI-assisted global monitoring

Bottom Line

The repositories in this episode reveal a useful shift: agent software is separating into communication, governance, execution, browser access, review, reusable skills, and domain-specific applications. That is healthier than expecting one assistant to own every concern.

The highest-value stack is not the one with the most agents. It is the smallest stack that creates accepted work with visible cost, repeatable evaluation, narrow permissions, and a human decision at the consequential edge. Start with the constraint you can name, and make the second install earn its place.