Computer-use agents are models that look at a screen and operate a computer with the mouse and keyboard. To compare them fairly, you need a shared set of tasks and a way to score them. OSWorld-V2 supplies both, with a focus on long tasks that resemble real work.

An agent runs inside a virtual machine, either a Docker image or an AWS machine. Some tasks also use mocked websites and a self-hosted GitLab. The Python task classes and assets are not in the GitHub repo. They live in gated Hugging Face datasets, which the authors say reduces answer leakage. Each benchmark release pins the code, tasks, assets, websites and VM images so runs stay comparable.

It succeeds the original OSWorld (xlang-ai/OSWorld), and the README includes a migration guide from 1.0. It recommends the osworld-v2.1 release, not the main branch, for reproducible results.

Read more on interesting repos · GitHub

Manus is an AI agent product that was available by invite only. OpenManus is a community project from contributors in the MetaGPT group that lets you run a similar kind of agent yourself. The README calls it a simple implementation and says the first prototype was built in about three hours.

You install it with Python, put an LLM API key in a config file, and run python main.py. Then you type your idea in the terminal and the agent works on it. For web tasks it starts Browser Use as a default MCP server, so the agent gets browser tools for running commands and taking screenshots.

Besides the main agent, there is an MCP tool version and an experimental multi-agent flow. The flow can add a DataAnalysis agent for data analysis and charts. The README says it builds on anthropic-computer-use, browser-use and crawl4ai. A sibling project, OpenManus-RL, covers reinforcement-learning tuning of LLM agents.

Read more on interesting repos · GitHub

Octop is an AI assistant platform for households and small teams. One process serves a web dashboard, a command line, chat channels (Feishu, DingTalk, QQ, WeChat, Telegram, Discord, WeCom) and scheduled jobs. Conversations, workspaces and credentials stay on your machine, in SQLite by default or PostgreSQL if you prefer.

Each user can have several agents, which Octop calls experts. Every expert has its own workspace, model providers, channels and cron jobs. You can start from a library of expert templates, give an expert one of 16 MBTI personalities, and share setups with other users on the same deployment. An AgentTeams mode, still in beta, lets a coordinator hand multi-step work to several experts.

It is a Python and FastAPI app with a React front end. It combines separate Tencent-built parts for the agent runtime, chat gateway, memory and browser automation. Web, chat and cron all go through one in-process handler, with no external message queue. It also speaks ACP both ways: an IDE can use your agent, and your agent can hand coding work to tools like Claude Code or Codex.

Read more on interesting repos · GitHub

Most AI chats start from zero, so you re-explain your audience, offers and voice each time. Campus AI OS writes that context into readable Markdown and JSON files in one folder, and every job starts from those files.

You talk to one AI, Dean, the chief of staff. Dean pulls the context a job needs, hands it to a department (Community, Education, Marketing or Sales), runs a playbook, and records what happened. Each run writes a results file, and an activity ledger logs who did what.

It is aimed at one-person businesses, not email and calendar assistance. There is no server, database, account or API key. It runs inside Claude Desktop, Cowork, Claude Code or Codex, and a /campus-doctor command checks the setup in plain language.

Read more on interesting repos · GitHub

eve treats the filesystem as the way you write an agent. You put a system prompt in instructions.md, typed tools in a tools folder, and on-demand procedures in a skills folder. Anyone opening the project can see what the agent can do.

The same layout covers how the agent reaches people and when it runs. Channels (HTTP, Slack, Discord) carry messages, and schedules hold recurring cron jobs. The model is chosen by AI Gateway model ID in a small agent.ts file, and tools are plain functions with a Zod input schema.

The README does not compare eve to other frameworks by name. It stresses that projects are easy to inspect and operate, and that the package ships its docs in node_modules so coding agents can read them locally. It is in beta, so APIs may change before general availability.

Read more on interesting repos · GitHub

Maka runs AI agents that read files, run shell commands and edit code. Its main idea is that the event log is the runtime. Every model message, tool call, permission decision and ending is added to an append-only log of RuntimeEvents.

The desktop screen, the next prompt sent to the model and crash recovery are all built from that log. Old tool output can be dropped from the next prompt and still stay in the log. Sessions, settings and run records stay on your machine, and you bring your own model: a cloud API, a local model or a compatible gateway.

Desktop, the TUI and CLI are thin clients of a single Runtime Host. The project also ships an evaluation package that benchmarks Maka against other agent harnesses on the same model with the official verifier. It says it publishes per-task results in docs/eval. The README does not name specific rival tools. It is an Apache Incubator project with no Apache release yet, and the README warns that data formats and commands may change.

Read more on interesting repos · GitHub

Lumina is a desktop AI agent that runs on your own computer. It was built and tested on a 4GB Nvidia Quadro T1000, so the author kept prompts and tool definitions lean for small local models. The README argues that many assistants waste context on bloated prompts, and Lumina tries to avoid that.

It has a native PySide6/Qt interface instead of an Electron shell. Behind the chat window is one shared interface for 14 model backends. These include llama.cpp, Ollama, LM Studio and vLLM locally, plus cloud options like Anthropic, Google and OpenAI. You can switch backends from a Settings dropdown without a restart.

Memory and safety get a lot of attention. Memory is split into several parts: a decaying layered store, chat history search, a knowledge base and a step called Dreaming. Sessions are marked as owner or non-owner. Non-owner sessions start with all tools off, and outside content is treated as data, not instructions. The README is candid that you need a GPU and some comfort with a terminal. It is also in public beta, and macOS and Windows support is still being tested.

Read more on interesting repos · GitHub

Rakazo is an open-source platform for running AI teammates that stay around. Each bot keeps its own chat history, memory and routines. You reach them from a web app, an Electron desktop app or an Expo mobile app. The project is in beta.

Each bot gets a computer to work on, either a shared team machine or an isolated private one. It comes with a browser, terminal, files and a graphical desktop. The sandbox can be local Docker or a remote provider such as E2B, Daytona, CreateOS or Box. Bots can also hand work to peer bots or short-lived subagents.

The GitHub description calls it an open-source alternative to Grok Bot. You bring your own model credentials and choose your own sandbox instead of being tied to one vendor. The backend is TypeScript with PostgreSQL, Hono and Graphile Worker.

Read more on interesting repos · GitHub

Agents are only useful if they can do things in other apps: read email, file tickets, post messages. Each app has its own API and its own login rules. Composio packages those integrations as toolkits and handles authentication for you.

You create a session for each of your users, then hand that session's tools to your agent. By default the session gives the agent a few meta tools that find, authenticate and run app tools while it works. This means you don't load hundreds of tool definitions into the model's context.

Provider adapters convert the tools into the format your agent framework expects, such as OpenAI Agents, Claude Agent SDK, Vercel AI SDK, LangChain or CrewAI. If your framework isn't listed, you can write a custom provider or connect over MCP, since every session can expose a hosted MCP endpoint.

Read more on interesting repos · GitHub

Most AI stock pickers give one confident opinion. Investment Council asks the same question through 21 investor styles, such as Warren Buffett, Peter Lynch and Michael Burry, and puts the answers side by side. The disagreement is the useful part: if five like a stock and one doesn't, you see that.

It runs as six steps inside Claude Code. Step 1 is plain Python that pulls prices and fundamentals from Yahoo Finance and does the math. Claude then writes each investor's reasoning, a consensus heat map, position sizing, and BUY/ADD/HOLD/SELL/PASS calls, and finally a report and dashboard. Each step saves a plain text file you can read and edit before the next one starts.

The README says the AI never invents numbers. It only explains the ones Python gave it, and a validate.py script checks they stay in sync. The tool does not trade for you and is not financial advice.

Read more on interesting repos · GitHub

OpenWork is a desktop app that gives an AI agent a workspace on your computer. The agent works on your own files, and they stay local. Cloud features are optional. It is built on OpenCode and is pitched as an alternative to Claude Cowork and Codex.

You choose the model. Use your own API keys, sign in with ChatGPT, or run local models through Ollama or any OpenAI-compatible server. Skills, Claude-compatible plugins and MCP servers from a Cowork setup can carry over.

You don't have to use the app. OpenWork also offers a remote MCP server. Add it to Codex, Claude Code, Cursor or OpenCode, and those tools can reuse the same skills and connections. For organizations, a control plane called Den handles access, shared skills and policies. Den is under a source-available license, while the rest is MIT.

Read more on interesting repos · GitHub

Iron Jarvis tries to be an operating system for AI agents rather than a chatbot. You type into one chat surface. Quick questions get a fast answer, and requests that need real tool work are handed to a full agent, with a visible reason.

A supervisor splits a goal across subagents such as Planner, Builder, Reviewer and Researcher. Each works in a disposable git worktree. Code lands on a branch and is never merged automatically, so you read the diff and approve it. Every tool call passes a permission engine that denies by default.

It can use cloud models through an API key or an existing claude/codex CLI login, or local servers such as Ollama, vLLM and LM Studio. A deterministic mock model lets it run offline. The README says the packaged installer is Windows-only. On macOS and Linux you run it from source.

Read more on interesting repos · GitHub

Most agents live behind a custom web page or API, but teams often want them in Slack or Microsoft Teams. Each platform has its own message format, credentials and event rules, so wiring an agent into each one is a lot of work.

Channels sits between your agent and the chat platform. A person sends a message, and CopilotKit Intelligence receives the platform event and passes it to a long-running Node process that you host. That process runs your agent over the AG-UI protocol, runs its tools, and returns a reply that Intelligence delivers as native UI, such as Slack Block Kit or Teams Adaptive Cards.

Your agent, model keys, tools and logic stay on your infrastructure. CopilotKit Intelligence handles platform credentials, incoming events, delivery and reconnects. It can be hosted by CopilotKit or self-hosted for enterprise use. The repo description also names Discord and Telegram, but the README says managed connections cover Slack and Teams, with more channels coming.

Read more on interesting repos · GitHub

Teams usually spread work across chat, a git forge, bots, CI dashboards and search tools. Buzz tries to put these on one base. It is a Nostr relay, so every message, reaction, workflow step, review approval and git event is a signed event in a single log.

Agents get their own keypair, channel memberships and audit trail, and are added to a channel the way a person is. They can open repos, send patches, review code, run workflows, edit canvases and create channels. Access is scoped by identity rather than by permission flags.

A desktop app (Tauri and React) is the main client, and buzz-cli gives agents a JSON-in, JSON-out interface. An ACP harness connects agents such as Goose, Codex and Claude Code. The relay uses Postgres, Redis and S3-compatible storage. The README is open about maturity: mobile clients and workflow approval gates are still in progress, and web-of-trust reputation and push notifications are only planned.

Read more on interesting repos · GitHub

OpenTag is a ready-made chat agent for Slack and Microsoft Teams. You mention it in a thread and it replies there. It can turn an uploaded CSV into a native Slack chart, do web research with cited sources, and create Linear or Notion items.

It is the assembled example for CopilotKit's Channels SDK, which connects any AG-UI agent to chat apps. A Node runtime handles the channel connection and a Python LangGraph agent does the work. The README says the agent, persona, tools and UI are each one file or directory, so you can swap in your own agent without touching the channel lifecycle.

Writes to Linear and Notion pause for a human to approve, and the button click resumes the LangGraph run. The quick start uses a managed CopilotKit Intelligence Channel for delivery, state and concurrency. You can instead run your own channel runner on the open-source SDK. Setup needs a CopilotKit account, an OpenAI key and a Slack workspace.

Read more on interesting repos · GitHub

Most agent tests check whether a model can call a tool. AutomationBench asks a harder question: can the agent finish a real business workflow, like routing a support ticket or onboarding an employee, and leave the systems in the right state?

Each task starts with trigger data and a pre-filled simulated environment spanning 47 SaaS tools. The agent gets tools to work with it and runs on its own, with no user to talk to. When it stops, the final state is compared with the expected state using assertions. Every task has to be checkable by code.

The public repo has 600 scored tasks, 100 each in sales, marketing, operations, support, finance and HR, plus 200 easy tasks as a warm-up. The official leaderboard uses a separate, harder private task set, so local scores point the same way but won't match exactly.

Read more on interesting repos · GitHub

OpenHuman is an agent harness: the layer that runs an AI agent, gives it tools, memory and search, and keeps track of conversations. Its core is written in Rust and runs in the same process as the app, not as a separate background service. The same core backs a Tauri desktop app (Windows, macOS, Linux), a browser UI, a terminal client and a Rust library called openhuman-embed.

Almost every engine is chosen by config. LLMs can be Ollama, LM Studio, MLX, any OpenAI-compatible server, Claude Code, or 26 bring-your-own-key providers. Memory defaults to a local store mirrored as an Obsidian vault, and can be switched to Mem0, Supermemory and others. Web search can be managed or your own Brave, Exa, Tavily or SearXNG. Cargo feature flags let you compile out parts you don't need.

The README compares it with Claude Cowork, OpenClaw and Hermes Agent, and with n8n and Zapier for workflows. Its stated differences are low memory per agent, persistent memory of your data, and workflows the agent drafts for you to review. It is early beta and GPL-3.0. The performance and accuracy figures are the authors' own benchmarks, and some features need a TinyHumans account or API key.

Read more on interesting repos · GitHub

AI-Trader is a trading platform built for AI agents as well as humans. An agent registers by reading a skill file from the project's site. After that it can publish signals, take part in discussions and follow other traders.

The repo holds a FastAPI backend, a React frontend, agent skill definitions and OpenAPI specs. Background workers fetch prices, track profit history and settle trades separately from the web service. US stock prices come from Alpha Vantage, with yfinance as a fallback. The README also mentions Polymarket paper trading.

The README says it covers stocks, crypto, forex, options and futures. You can keep your own broker (Binance, Coinbase and Interactive Brokers are named) and sync trades to the platform. New users can practice with simulated money. The README gives no performance figures, so judge any signals yourself.

Read more on interesting repos · GitHub

TradingAgents models a trading firm with LLM agents. Each agent has one job. Analysts study a stock from different angles, researchers argue for and against it, a trader proposes a move, and a risk team and portfolio manager approve or reject it.

You pick a ticker and a date. Four analysts (fundamentals, sentiment, news, technical) work at the same time and write reports. A bullish and a bearish researcher then debate those reports, the trader drafts a decision, and the risk team reviews it. Approved orders go to a simulated exchange, not a real one.

It works with many model providers, including OpenAI, Google, Anthropic, xAI, DeepSeek, Mistral, Groq, AWS Bedrock, and local servers such as Ollama, vLLM and LM Studio. It comes from an academic paper (arXiv 2412.20138) and is meant for research. The authors say it is not financial, investment or trading advice.

Read more on interesting repos · GitHub

A coding model on its own only writes text. Ruflo calls the layer around it the harness: the tools, memory, loops and controls that let the model do real work. Ruflo is that layer for Claude Code and Codex.

After you run its init command, it adds an MCP server, hooks, a background daemon and a library of agent definitions, commands and skills to your project. The README says the hooks route tasks, learn from patterns that worked, and coordinate agents in the background while you keep using Claude Code as usual.

There are two ways in. A lighter route installs individual Claude Code plugins as slash commands and agent definitions, with no files added to your workspace. The full CLI install adds the whole loop, including hooks and the daemon. The README lists 35 plugins covering memory, swarms, testing, security scanning, cost tracking and more.

Read more on interesting repos · GitHub

Financial questions are rarely one lookup. You might need several years of income statements, a cash flow comparison, and some web research before you can answer. Dexter handles that chain. It takes a question, writes a research plan, and works through it.

It runs in your terminal. For each step it picks a tool, such as one that fetches income statements, balance sheets or cash flow statements from the Financial Datasets API. It reviews what it found and keeps going until the task is done. Loop detection and step limits stop it from running forever.

The README describes it as Claude Code built for financial research. It works with several model providers (OpenAI, Anthropic, Google, xAI, OpenRouter, or local Ollama). It logs every tool call to a file so you can see what it did. The authors say it is for education and information only, not for real trading or investment advice.

Read more on interesting repos · GitHub

Building an agent usually means wiring a model to tools, keeping conversation history, checking inputs and outputs, and passing work between specialists. This SDK packages those pieces. You define an Agent with instructions and tools, then run it with a Runner.

Agents can call functions, MCP servers and hosted tools. They can hand work to other agents, or use another agent as a tool. Guardrails check input and output, human-in-the-loop steps let a person step in, and sessions keep history between runs. Tracing records each run so you can view and debug it.

Beyond text agents, there are sandbox agents that work inside a container (inspect files, run commands, apply patches), realtime agents for low-latency voice over WebSocket, and a voice pipeline that chains speech-to-text, an agent and text-to-speech. The README says it supports the OpenAI Responses and Chat Completions APIs plus 100+ other LLMs. A JavaScript/TypeScript version lives in a separate repo.

Read more on interesting repos · GitHub

Hermes Agent is a personal AI agent you run yourself. You talk to it in a terminal interface or through Telegram, Discord, Slack, WhatsApp, Signal or email. One gateway process handles all the chat platforms, so a conversation can carry across them.

Its main idea is a learning loop. After complex tasks it can write a reusable skill, and it improves that skill with use. It keeps notes in memory, searches past conversations, and builds a profile of you over time. The README says its skills follow the agentskills.io open standard.

It isn't tied to one model or one machine. You pick a provider with `hermes model`, including Nous Portal, OpenRouter, OpenAI or your own endpoint. Tools can run locally, in Docker, over SSH, or on Singularity, Modal, Daytona or Vercel Sandbox. That lets it live on a cheap server while you chat from your phone. The README also covers migrating from OpenClaw.

Read more on interesting repos · GitHub

If you use several coding agents, each one lives in its own terminal tab and forgets context when the session ends. Multica puts those agents and your human teammates on one board. You file an issue, set an agent as the assignee, and it picks the work up, comments as it goes, and moves the issue to review when done.

It does not ship a model. A small daemon runs on your laptop or a cloud machine, next to your code, and launches the agent CLIs you already have installed and signed in. The README lists 26 of them, including Claude Code, Codex, Cursor Agent, Copilot CLI and Kimi. A Go backend with PostgreSQL keeps the issues, runs and logs; web, desktop and mobile apps sit on top.

The idea is that the intent, the run, the decisions and the diff all stay attached to one issue. Work lands in review rather than in main, so a person decides what ships. Note the README calls it source-available, and the license field on GitHub is not a standard one, so check the terms before you build on it.

Read more on interesting repos · GitHub

Paperclip Companies is a catalog for the Paperclip platform. Each entry is a team of AI agents with reporting lines (a CEO, directors, specialists), a set of skills, and governance settings. You import a team and run it.

Most companies are built from existing open-source skill collections, such as gstack, Superpowers, Trail of Bits skills, K-Dense scientific skills, ClawTeam and Claude-Code-Game-Studios. The repo repackages each one as an org of agents, and the README links back to every source project.

The teams are domain-specific: engineering shops, a security auditor, a science lab, an investment analysis team, a game studio and a consultancy. The README text is cut off partway through, so details of the later entries are thin.

Read more on interesting repos · GitHub

Machine learning research usually means a person tweaks code, trains a model, reads the result, and tries again. This project hands that loop to an AI agent. It uses a simplified single-GPU version of nanochat, a small LLM training codebase, as the thing being improved.

The repo has three files that matter. prepare.py downloads data, trains a tokenizer, and holds the evaluation code, and it stays fixed. train.py holds the GPT model, the optimizer (Muon and AdamW), and the training loop, and the agent is free to rewrite it. program.md holds the instructions for the agent, and that is the file you edit.

Every run gets the same 5-minute wall-clock budget and is scored by val_bpb (validation bits per byte), where lower is better. Because the budget and metric are fixed, results are comparable whatever the agent changes. The catch is that results are not comparable across different hardware.

Read more on interesting repos · GitHub

If you run many AI agents at once, say a pile of Claude Code terminals, it is hard to know who is doing what, what it costs, and what happens after a reboot. Paperclip puts them behind one task manager. You describe a goal, set up the agents as an org chart, and watch the work from a dashboard.

It is a Node.js server with a React interface. Each agent is added through an adapter, and the README says anything that can receive a heartbeat can be hired. Agents wake for assigned tasks, follow-up messages or schedules, and goal context passes down from the company to the project to the task.

The README contrasts it with running agents by hand or with folders of scripts and configs. Paperclip adds ticketing, delegation, approval stages, budgets with automatic pauses, and run history. It names OpenClaw, Claude Code, Codex, Cursor, Gemini CLI and OpenCode as supported agents.

Read more on interesting repos · GitHub

OpenClaw is an AI assistant you run yourself. Instead of opening a separate website, you talk to it in the messaging apps you already use, such as Discord, Telegram, Slack, WhatsApp and iMessage, or through native apps for macOS, iOS, Android, Windows and Linux.

A program called the Gateway sits at the centre. It runs locally and manages sessions, tools, events and the connections to each chat channel. The command line, a web Control UI and a terminal UI all connect to it. The same Gateway can serve one person on a laptop or a whole team; the README says configuration is the only difference.

Models are plugins. You can use Claude, Codex or local models and change them without touching the rest of the setup. State, memory and credentials stay on your hardware, though your prompts still go to whichever model provider and chat platforms you configure. The project is stewarded by an independent non-profit foundation and says it has no paid tier or hosted service.

Read more on interesting repos · GitHub