这个真不错，Paperclip 居然可以把一群 AI agent 当成一家公司来管。
再也不用开二十个终端盯着每个 agent 了，任务、预算、权限都在一个看板里，这波真的可以冲。
paperclipai/paperclip
3 likes · 120 views
paperclip ai: How to Set Up the Free, Open-Source App for Managing AI Agents
paperclip ai is trending again on GitHub this week, and a lot of people are searching for a "paperclip ai tutorial" or "paperclip ai setup". If you run a small business or a small dev team and you already use one or more AI coding agents, here's a plain, research-based walkthrough of what Paperclip is, how to install it, and what to watch before you let agents run on their own.
What Paperclip is
According to its GitHub README, Paperclip is "open-source orchestration for teams of AI agents". In practice it's a Node.js server with a React dashboard where you:
- set a goal for the work,
- "hire" agents into roles on an org chart ("any bot, any provider", in the README's words),
- assign tasks, approve plans, set budgets, and watch progress from one place.
It's MIT-licensed and self-hosted, and the README says no Paperclip account is needed. The repo had just over 110,000 stars when we checked the GitHub API today.
It works with agents you may already use. The README lists OpenClaw, Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Hermes and Kimi Code, among others, plus custom processes and HTTP endpoints.
Quick setup
The README's quickstart needs Node.js 24.11 or newer. Then one command:
npx paperclipai@latest onboard --yes
The CLI runs from npm's cache, and your instance settings and data stay on your machine. For a local run, the README's FAQ says a single Node.js process manages an embedded PostgreSQL database and local file storage, so there's no separate database to set up. For production you can point it at your own Postgres.
If you'd rather build from source, the README's development steps are pnpm install then pnpm dev, which starts the UI and API at http://localhost:3100 (it needs pnpm 9.15+).
The full installation guide covers pinned versions, updates, rollback and uninstalling.
A simple first project for a small team
Keep the first run small and boring:
1. One goal, one or two agents. For example, "Clean up our website's FAQ page and open a pull request." Don't start with a company-wide goal.
2. Turn on review gates. Paperclip has configurable approval stages, so a human checks a plan before work starts.
3. Set a budget. The README says you can set company, agent and project budgets, get threshold alerts and pause work at a limit. Paperclip itself is free, but the AI models your agents call are not, so set the cap before you hit "go".
4. Read the task threads. Plans, blockers, files and run history stay attached to each task, which makes it easier to see what an agent actually did.
Things to check before going autonomous
- Scope the secrets. The README mentions scoped secrets and permissions. Give each agent only the keys and repos it needs.
- Start in a test repo. Let agents work on a copy before they touch anything customers see.
- Keep a human on merges. "Approve and run" is the README's own workflow. Keep the approve part.
Is it worth trying?
If you're juggling several agent terminals and losing track of who's doing what, Paperclip is a free way to put that work on one board with budgets and approvals. If you only use one assistant now and then, it's probably more structure than you need today.
This is a research-based overview from the project's own README and docs. We haven't tested Paperclip hands-on yet.
More plain-English AI tool guides for small businesses and creators: ainews.useaifix.com. If you'd like help setting up AI automation for your business, see useaifix.com.
Paperclip's Agent Orchestration Stack: How Multi-Agent Teams Track Work, Budgets, and Tool Permissions in Production
Most multi-agent frameworks stop at message passing. Paperclip treats agent coordination as a company org chart problem: hierarchies, delegation rules, budget caps, and permission boundaries. The open-source stack (109K+ stars, Node.js server + React UI) positions itself as "the company" layer above individual agents. If OpenClaw is an employee, Paperclip is the HR system, finance department, and project management office rolled into one.
This matters because production agent teams need the same operational infrastructure as human teams. You need to know which agent spent $47 on API calls yesterday, who delegated a task to whom, and why the content-generation agent can't access your database. Paperclip exposes primitives for these problems that most orchestration tools ignore.
The Company Abstraction
Paperclip's core metaphor is organizational structure. You define agents as team members, assign them skills, set budget limits, and track their work history. The system maintains an org chart that determines delegation paths and escalation rules.
Key primitives:
- Agent profiles: Each agent has a model selection (GPT-4, Claude, local LLM), a harness (the execution environment), and a skill set (allowed tools and actions).
- Goal hierarchies: Top-level business goals decompose into tasks. Agents claim tasks based on skill matches and availability.
- Budget tracking: Per-agent cost attribution for API calls, tool usage, and compute time. Hard caps prevent runaway spending.
- Permission boundaries: Agents inherit permissions from their position in the org chart. A junior agent can't approve expenses or access production databases.
The UI looks like a task manager. The backend is a state machine that routes work, enforces budgets, and logs every decision for audit trails.
Architecture: Node.js Orchestrator + React Dashboard
Paperclip runs as a Node.js server that manages agent state and a React frontend for human oversight. The server handles task assignment, budget enforcement, and tool permission checks. The UI shows real-time agent activity, cost breakdowns, and task progress.
Component breakdown:
| Component | Responsibility | State Persistence |
|-----------|---------------|-------------------|
| Orchestrator | Routes tasks to agents, enforces budget caps, checks permissions | PostgreSQL for task history, agent profiles, and audit logs |
| Agent Harness | Executes agent code (local process, Docker container, or remote API) | Ephemeral; logs sent to orchestrator |
| Skill Registry | Maps tool names to permission requirements and cost models | JSON config files, hot-reloadable |
| Budget Tracker | Aggregates costs per agent, per task, per time window | Time-series database (InfluxDB or Prometheus) |
| Audit Logger | Records every task assignment, delegation, tool call, and budget decision | Append-only log (S3 or local file) |
The orchestrator maintains a task queue. When a new goal arrives, it decomposes into subtasks and assigns them to agents based on skill matches. If an agent hits its budget cap, the orchestrator pauses its tasks and escalates to a supervisor agent (or a human).
Task Routing and Delegation
Paperclip's task assignment uses a skill-matching algorithm. Each task declares required skills (e.g., "web scraping", "data analysis", "content generation"). Each agent declares available skills. The orchestrator finds the best match and assigns the task.
Delegation rules:
- Agents can delegate tasks to subordinates in the org chart.
- Delegation requires explicit approval if the subordinate's budget cap is lower than the task's estimated cost.
- Escalation happens automatically when an agent can't complete a task (missing skills, budget exhausted, or explicit failure signal).
The system tracks delegation chains. If Agent A delegates to Agent B, who delegates to Agent C, the audit log shows the full path. This matters for debugging and cost attribution.
Example delegation flow:
// Simplified task assignment logic
async function assignTask(task: Task, orgChart: OrgChart): Promise<Agent> {
const candidates = orgChart.agents.filter(agent =>
agent.skills.includes(task.requiredSkill) &&
agent.budgetRemaining >= task.estimatedCost
);
if (candidates.length === 0) {
// Escalate to supervisor
const supervisor = orgChart.getSupervisor(task.assignedTo);
return assignTask(task, orgChart, supervisor);
}
// Pick agent with lowest current workload
const selected = candidates.sort((a, b) =>
a.activeTasks.length - b.activeTasks.length
)[0];
await logDelegation(task, selected);
return selected;
}
Budget Tracking and Cost Attribution
Every tool call, API request, and compute minute gets logged with a cost estimate. Paperclip aggregates these costs per agent, per task, and per time window. Budget caps are hard limits: when an agent exhausts its budget, the orchestrator pauses its tasks.
Cost tracking flow:
1. Agent requests a tool call (e.g., "search web for competitor pricing").
2. Orchestrator checks agent's remaining budget.
3. If budget allows, orchestrator estimates cost (based on tool's cost model) and reserves that amount.
4. Tool executes, returns actual cost.
5. Orchestrator updates agent's budget and logs the transaction.
The system supports budget rollover (unused budget carries to next period) and budget pooling (team budget shared across agents). These are config options, not hardcoded policies.
Budget enforcement table:
| Scenario | Behavior | Escalation Path |
|----------|----------|-----------------|
| Agent under budget | Task proceeds normally | None |
| Agent at 90% budget | Warning logged, task proceeds | Notify supervisor |
| Agent at 100% budget | Task paused, no new assignments | Escalate to supervisor for budget increase or task reassignment |
| Task exceeds agent's total budget | Task rejected at assignment time | Escalate to higher-tier agent or human |
Permission Boundaries and Tool Access
Agents inherit permissions from their org chart position. A junior agent can read from the knowledge base but can't write. A senior agent can approve expenses up to $500. A supervisor can access production databases.
Permissions are declarative. Each tool declares required permissions (e.g., "database:write", "expense:approve"). Each agent has a permission set. The orchestrator checks permissions before allowing tool calls.
Permission check example:
// Before executing a tool call
async function checkPermissions(agent: Agent, tool: Tool): Promise<boolean> {
const requiredPerms = tool.requiredPermissions;
const agentPerms = agent.permissions;
const hasAllPerms = requiredPerms.every(perm => agentPerms.includes(perm));
if (!hasAllPerms) {
await logPermissionDenial(agent, tool, requiredPerms);
return false;
}
return true;
}
Permission violations get logged to the audit trail. Repeated violations trigger alerts. This prevents agents from accidentally (or maliciously) accessing resources they shouldn't touch.
State Persistence and Audit Trails
Paperclip persists agent state, task history, and audit logs to PostgreSQL. Long-running tasks survive server restarts. The audit log is append-only: every task assignment, delegation, tool call, budget decision, and permission check gets recorded with a timestamp and agent ID.
Audit log schema (simplified):
CREATE TABLE audit_log (
id SERIAL PRIMARY KEY,
timestamp TIMESTAMPTZ NOT NULL,
agent_id VARCHAR(255) NOT NULL,
event_type VARCHAR(50) NOT NULL, -- 'task_assigned', 'tool_called', 'budget_exceeded', etc.
task_id VARCHAR(255),
tool_name VARCHAR(255),
cost_cents INTEGER,
permission_checked VARCHAR(255),
metadata JSONB
);
The audit log supports compliance requirements (who did what, when, and why) and debugging (why did this task fail? which agent made this decision?). You can query it to generate cost reports, permission violation summaries, or agent performance metrics.
Multi-Tenant Considerations
Paperclip supports multiple teams (tenants) on a single server. Each team has its own org chart, budget pool, and permission set. Agents in Team A can't see tasks or data from Team B.
Isolation mechanisms:
- Database-level row-level security (RLS) filters queries by tenant ID.
- Agent harnesses run in separate processes or containers (Docker, Firecracker).
- Tool calls include tenant context; tools enforce tenant boundaries.
This matters for SaaS deployments or large organizations with multiple departments. You don't want the marketing team's agents accessing the finance team's data.
Failure Modes and Observability
Paperclip exposes metrics for agent health, task queue depth, budget burn rate, and permission denial rate. The dashboard shows real-time alerts when agents fail, budgets run low, or tasks stall.
Common failure modes:
- Agent crashes: Harness process dies. Orchestrator detects via health check, reassigns tasks to another agent.
- Budget exhaustion: Agent hits cap mid-task. Orchestrator pauses task, escalates to supervisor.
- Permission denial: Agent tries to call a tool it can't access. Orchestrator logs denial, returns error to agent.
- Task timeout: Agent doesn't complete task within deadline. Orchestrator cancels task, reassigns to another agent.
The system integrates with Prometheus for metrics and Grafana for dashboards. You can set up alerts for budget overruns, high permission denial rates, or task queue backlog.
When to Use Paperclip
Use Paperclip when:
- You need to manage multiple agents with different skill sets and budget constraints.
- You want audit trails for compliance or debugging.
- You need permission boundaries to prevent agents from accessing sensitive resources.
- You're running long-running workflows that span multiple sessions.
Avoid Paperclip when:
- You have a single agent or a simple pipeline (too much overhead).
- You need real-time, low-latency coordination (the orchestrator adds routing latency).
- You want to run agents in a fully decentralized way (Paperclip assumes a central orchestrator).
Technical Verdict
Paperclip solves the operational problems that emerge when you move from one-off agent demos to production multi-agent systems. The org chart abstraction is opinionated but practical: it maps cleanly to how organizations already think about delegation, budgets, and permissions.
The stack is production-ready for teams that need cost control, audit trails, and permission enforcement. The Node.js + React architecture is straightforward to deploy and extend. The skill-matching and budget-tracking primitives are reusable building blocks.
The main trade-off is centralization. The orchestrator is a single point of failure and a potential bottleneck. If you need fully decentralized agent coordination, look elsewhere. But if you're building a system where agents need to operate within organizational constraints (budgets, permissions, hierarchies), Paperclip exposes the plumbing you'll need.
Source Links
- Paperclip GitHub Repository
- Paperclip Documentation
- Paperclip Discord
Paperclip’s October release adds persistent agent files across tasks and support for syncing company skills from GitHub repositories.
The interesting product question: how do teams keep shared agent instructions useful as they grow?
github.com/paperclipai/paperclip/releases
2 likes · 115 views
Give your AI agents an org chart, budgets and a boss with Paperclip, the open-source way to run Claude Code, Codex and friends like a company 📎 🔗 paperclipai/paperclip
Credits: paperclipai/paperclip
#paperclip #typescript #aiagents
Meet Kowalski
---
title: Meet Kowalski
published: true
description: A small team of AI agents on your own computer, on a free local model. You hand it a chore, it hands you a file.
tags: opensource, rust, ai, localllm
canonical_url: kowalski.yarenty.com
cover_image: kowalski.yarenty.com
---
October 2026
This post first appeared on the Kowalski blog. It's written for people who have never heard of Kowalski, so let's start at the beginning.
Kowalski is a small team of AI agents that lives on your own computer and does chores for you. Not a chatbot you have to keep talking to, and not a platform you have to administer. You hand it a job, it does the job, and you get a file back. It's open source (MIT), written in Rust, and it runs on a free local model through Ollama, or on any hosted model with your own key.
There are two well-known open-source projects in the same neighbourhood, and they help to explain what Kowalski is by what it isn't. OpenClaw is a personal assistant you chat with: it gets wide access to your machine and your apps, and it works best with a big frontier model behind it. Paperclip goes one level up: it runs a whole "company" of paid coding agents, with org charts, budgets and approvals. Both are impressive. Kowalski makes the opposite bet. Each job is a small, fixed pipeline you can read. The agents only touch the one folder you give them, and they ask before doing anything risky. The hard parts (fetching pages, running SQL, building spreadsheets) are ordinary code, so a small free model on a laptop is enough. The result is cheaper (€0 a run on a local model), more private (nothing leaves your machine), and easier to trust (every number comes from a query, not from the model's imagination). Penguins: no lobsters, no corporation.
So what do you actually give it? A chore: a question about a spreadsheet, the five pages you read every morning, a document that just landed in your inbox, a topic to research. Kowalski hands the chore to a horde, a short pipeline of specialised agents we call penguins, and gives you back something you can use: a report workbook, a one-page brief, a note in your Obsidian vault.
!A first run of kowalski: install, Setup, connect tableski, drop a workbook, get answers
What it does today
Five hordes come with it:h
- Spreadsheet analyst. Ask questions about your workbooks in plain words and get a report workbook back. The model writes the SQL; every number comes from a query engine, never from the model.
- Morning brief. The pages you follow, read for you: the few items worth your time, why each matters to you, and the link. It can run every weekday at 7:00.
- Folder watcher. Drop a document into its inbox and get a note: what it is, the key facts, and what to do by when.
- Knowledge compiler. Ask a question and list the pages that should answer it. You get one note with its sources, saved straight into your Obsidian vault.
- URL summarizer. A list of links in, a short summary of each out.
A horde is a folder of plain Markdown files, so you can read exactly what each penguin is told, copy one and change it, or have kowalski build a new one with you.
How it got here
Kowalski started on 4 March 2025 as a weekend experiment: a Rust program that could talk to a local Ollama model. Here's the short version of what happened next.
- 2025: big plans. By the summer it had a five-layer architecture, a crate per agent, three databases and a federation layer for a distributed system nobody was running. It was a good exercise and a bad product: nothing in it could be handed to someone who doesn't write Rust.
- Early 2026: smaller. 1.0 deleted most of that on purpose. One agent type instead of many crates, SQLite instead of three databases, an HTTP server and a web UI, and tools reached through MCP.
- Spring 2026: hordes. The idea that gave the project its shape: a pipeline as a folder of Markdown. Builders, graphs with loops, then triggers (cron, file watch, webhook) and durable runs that survive a restart.
- September 2026: the product. One binary with the UI inside, a three-question Setup, ready-made hordes, and data steps that keep numbers out of the model. Since 2.5: a signed Mac app you install by dragging it to Applications.
Eighteen months and more than 700 commits later, the pattern is clear: almost every good change removed something. The long version of that story is Eighteen months of Kowalski.
Who it's for
People with recurring chores and data they'd rather keep on their own machine: a small business owner with a sales workbook, an engineer who reads the same five sites every morning, a researcher whose notes live in Obsidian. If you write code, a horde is a folder you can version, review and share.
Try it
On a Mac, download Kowalski.dmg, drag it to Applications and open it. On a Mac or Linux, from a terminal:
curl -fsSL https://raw.githubusercontent.com/yarenty/kowalski/main/install.sh | bash
kowalski
Your browser opens on Setup: pick a model, a folder, and optionally your tableski account. Then pick a horde and send it in. Everything is at yarenty/kowalski.
If something goes wrong, open an issue. Kowalski does the analysis; I do the apologising. And if everything works first time, just smile and wave, boys. Smile and wave. 🐧
Originally published on the Kowalski blog.
Paperclip’s latest release adds private agent tasks, persistent identities, external model gateways and more detailed cost accounting.
paperclipai/paperclip
2 likes · 2 reposts · 886 views
한 달에 ★45,470 붙은 GitHub 저장소의 정체 (10월 트렌딩 TOP 5)
이번 달 GitHub 트렌딩(월간)에서 스타가 가장 많이 늘어난 저장소 5개를, 뭘 하는 건지·왜 뜨는지까지 설명합니다.
0:00 한 달에 스타 4만 5천 개가 붙은 저장소?
0:10 5위 ai-engineering-from-scratch
0:28 4위 ECC
0:50 3위 paperclip
1:12 2위 hindsight
1:33 1위 VoiceStudio
1:55 한 줄 정리
■ 이번 영상의 저장소
5위 rohitg00/ai-engineering-from-scratch
4위 affaan-m/ECC
3위 paperclipai/paperclip
2위 vectorize-io/hindsight
1위 debpalash/VoiceStudio
■ 데이터 기준
- 순위·이번 달 증가 스타: GitHub 트렌딩(monthly) 2026-10-21 스냅샷. 증가량은 트렌딩 페이지 값이며 별도로 검증하지 못했습니다.
- 총 스타·라이선스·설명: GitHub API 2026-10-21 확인.
- "개발사 주장"과 "제 해석"은 영상에서 구분해 표시했습니다. hindsight의 LongMemEval 91.4%는 개발사가 논문에 밝힌 자체 결과입니다.
- 스타 수는 품질을 보장하지 않습니다.
- VoiceStudio는 AGPL-3.0 라이선스입니다. 상업적으로 쓰기 전에 직접 확인하세요.
■ 음성
내레이션은 AI 음성(Gemini TTS)입니다.
#GitHub #깃허브 #GitHub트렌딩 #오픈소스 #AI에이전트 #개발자 #AI개발
109 likes · 3 comments · 36 views
7 GitHub Repos That Feel Illegal to Know (October 2026)
Seven open-source projects exploding on GitHub right now: a free voice-cloning studio, PS5 games running natively on PC, an AI agent that got its creator hired, free AI models from 34 providers, directed AI filmmaking, videos rendered from code, and a "company" made of AI agents. What each one does, who it helps, and the catch.
0:00 Seven repos, 120K+ new stars
0:32 #1 VoiceStudio: free, local voice cloning
1:38 #2 AnyPS5: PS5 games on PC, no emulator
2:41 #3 AI Job Search: the agent that got its creator hired
3:35 #4 FreeLLMAPI: 34 free AI providers, one API
4:20 #5 ArtCraft: direct your AI shot
5:00 #6 HyperFrames: write HTML, get a video
5:44 #7 Paperclip: a company of AI agents
6:20 Bonus: REA
6:48 Recap
Repos (star counts as of Oct 20, 2026)
VoiceStudio: debpalash/VoiceStudio
AnyPS5: boykopovar/AnyPS5
AI Job Search: MadsLorentzen/ai-job-search
FreeLLMAPI: tashfeenahmed/freellmapi
ArtCraft: storytold/artcraft
HyperFrames: heygen-com/hyperframes
Paperclip: paperclipai/paperclip
REA: morluto/rea
Only clone voices you have permission to use. AnyPS5 needs your own legally dumped games. Beware fake installers for AnyPS5 and REA: use the official repos above.
Demo footage and screenshots are from each project's README, used for commentary. Narration uses an AI voice.
3 likes · 85 views
Benchmarking Paperclip Agent Orchestration: Concurrent Task Throughput and Memory Overhead Under Load
Benchmarking Paperclip Agent Orchestration: Concurrent Task Throughput and Memory Overhead Under Load
When evaluating paperclipai/paperclip for production agent orchestration, I needed concrete performance data under realistic multi-user concurrency. Here's what I measured and where the architecture holds up.
Test Topology
Environment:
- Next.js 15.2 app router with React Server Components
- 4-core, 8GB VPS (DigitalOcean)
- PostgreSQL 16 with connection pooling (pgBouncer, 20 max connections)
- k6 load generator simulating 50 concurrent users
Scenario:
Each virtual user triggers a multi-step agent workflow:
1. Create new task via Server Action
2. Agent processes task (calls LLM via B-Lost relay gateway at https://b-lost.com/v1)
3. Stream incremental results back to UI via Suspense boundaries
4. Update task status in database
Code Configuration:
// app/actions/agent-task.ts
'use server'
import { z } from 'zod'
import { auth } from '@/lib/auth'
const TaskSchema = z.object({
prompt: z.string().min(10).max(2000),
agentId: z.string().uuid(),
})
export async function createAgentTask(data: z.infer<typeof TaskSchema>) {
const session = await auth()
if (!session) throw new Error('Unauthorized')
const validated = TaskSchema.parse(data)
// Paperclip agent dispatch
const response = await fetch('https://b-lost.com/v1/chat/completions', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.BLOST_API_KEY}`,
'Content-Type': 'application/json',
},
body: JSON.stringify({
model: 'claude-sonnet-4',
messages: [{ role: 'user', content: validated.prompt }],
stream: true,
}),
})
return response.body // Stream to client
}
// k6-load-test.js
import http from 'k6/http'
import { check, sleep } from 'k6'
export const options = {
stages: [
{ duration: '2m', target: 50 },
{ duration: '5m', target: 50 },
{ duration: '2m', target: 0 },
],
}
export default function () {
const payload = JSON.stringify({
prompt: 'Analyze this dataset and extract key metrics',
agentId: '550e8400-e29b-41d4-a716-446655440000',
})
const res = http.post('https://test-instance.com/api/agent-task', payload, {
headers: { 'Content-Type': 'application/json' },
})
check(res, {
'status 200': (r) => r.status === 200,
'response < 2s': (r) => r.timings.duration < 2000,
})
sleep(1)
}
Metric Comparison Table
| Metric | Cold Start (0 active tasks) | Steady State (50 concurrent) | Peak Load (80 concurrent) |
|--------|----------------------------|------------------------------|---------------------------|
| Avg Response Time | 420ms | 680ms | 1,240ms |
| p95 Latency | 580ms | 950ms | 1,850ms |
| p99 Latency | 720ms | 1,340ms | 2,680ms |
| Throughput (RPS) | 12.4 | 48.2 | 52.1 |
| Memory Consumption | 340MB | 780MB | 1,120MB |
| Database Connection Pool Saturation | 8% | 42% | 78% |
Key Observations:
1. RSC Streaming Holds Up Well: Even at p99, initial content rendered within 1.4s at steady state. Suspense boundaries prevented waterfall blocking.
2. Database Connection Pool Becomes Bottleneck: At 80 concurrent users, pgBouncer hit 78% saturation. Tasks queued for available connections, spiking p99 to 2.68s.
3. Memory Growth is Linear: paperclipai/paperclip's agent state management scaled predictably—no memory leaks observed over 30-minute sustained load.
4. B-Lost Gateway TTFT Consistency: When routing LLM requests through B-Lost's relay at https://b-lost.com/v1, time-to-first-token remained stable (median 380ms) with automatic fallback to backup providers during two brief Claude API timeouts.
Production Threshold
For teams evaluating paperclipai/paperclip:
Adopt if:
- You need coordinated multi-agent workflows with >20 concurrent users
- Your database can handle connection pooling (recommend 2x expected peak concurrency)
- You're already using Next.js App Router and want native RSC streaming
Avoid if:
- Your workload is <10 users with simple single-shot LLM calls (overhead isn't justified)
- You need sub-200ms p99 latency for agent responses (requires distributed task queue like BullMQ)
Configuration Adjustments:
To push beyond 80 concurrent users without latency degradation:
// Increase pgBouncer pool size
// config/database.ts
export const poolConfig = {
max: 40, // Up from 20
idleTimeoutMillis: 10000,
connectionTimeoutMillis: 3000,
}
// Add Redis-backed task queue for async agent jobs
import { Queue } from 'bullmq'
const agentQueue = new Queue('agent-tasks', {
connection: { host: 'localhost', port: 6379 },
})
The architecture remains sound—paperclipai/paperclip's design with React Server Components and Server Actions provides clean separation between UI and agent orchestration logic. At our measured throughput of 48 RPS under realistic load, the Next.js runtime handled concurrent agent state without custom locking or race conditions.
For latency-sensitive production deployments, pair with a proper task queue and scale database connections proportionally. The framework itself won't be your bottleneck until you're well past 100 concurrent agent workflows.
Mentions
这个真不错，Paperclip 居然可以把一群 AI agent 当成一家公司来管。 再也不用开二十个终端盯着每个 agent 了，任务、预算、权限都在一个看板里，这波真的可以冲。 paperclipai/paperclip
paperclip ai: How to Set Up the Free, Open-Source App for Managing AI Agents paperclip ai is trending again on GitHub this week, and a lot of people are searching for a "paperclip ai tutorial" or "paperclip ai setup". If you run a small business or a small dev team and you already use one or more AI coding agents, here's a plain, research-based walkthrough of what Paperclip is, how to install it, and what to watch before you let agents run on their own. What Paperclip is According to its GitHub README, Paperclip is "open-source orchestration for teams of AI agents". In practice it's a Node.js server with a React dashboard where you: - set a goal for the work, - "hire" agents into roles on an org chart ("any bot, any provider", in the README's words), - assign tasks, approve plans, set budgets, and watch progress from one place. It's MIT-licensed and self-hosted, and the README says no Paperclip account is needed. The repo had just over 110,000 stars when we checked the GitHub API today. It works with agents you may already use. The README lists OpenClaw, Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Pi, Hermes and Kimi Code, among others, plus custom processes and HTTP endpoints. Quick setup The README's quickstart needs Node.js 24.11 or newer. Then one command: npx paperclipai@latest onboard --yes The CLI runs from npm's cache, and your instance settings and data stay on your machine. For a local run, the README's FAQ says a single Node.js process manages an embedded PostgreSQL database and local file storage, so there's no separate database to set up. For production you can point it at your own Postgres. If you'd rather build from source, the README's development steps are pnpm install then pnpm dev, which starts the UI and API at http://localhost:3100 (it needs pnpm 9.15+). The full installation guide covers pinned versions, updates, rollback and uninstalling. A simple first project for a small team Keep the first run small and boring: 1. One goal, one or two agents. For example, "Clean up our website's FAQ page and open a pull request." Don't start with a company-wide goal. 2. Turn on review gates. Paperclip has configurable approval stages, so a human checks a plan before work starts. 3. Set a budget. The README says you can set company, agent and project budgets, get threshold alerts and pause work at a limit. Paperclip itself is free, but the AI models your agents call are not, so set the cap before you hit "go". 4. Read the task threads. Plans, blockers, files and run history stay attached to each task, which makes it easier to see what an agent actually did. Things to check before going autonomous - Scope the secrets. The README mentions scoped secrets and permissions. Give each agent only the keys and repos it needs. - Start in a test repo. Let agents work on a copy before they touch anything customers see. - Keep a human on merges. "Approve and run" is the README's own workflow. Keep the approve part. Is it worth trying? If you're juggling several agent terminals and losing track of who's doing what, Paperclip is a free way to put that work on one board with budgets and approvals. If you only use one assistant now and then, it's probably more structure than you need today. This is a research-based overview from the project's own README and docs. We haven't tested Paperclip hands-on yet. More plain-English AI tool guides for small businesses and creators: ainews.useaifix.com. If you'd like help setting up AI automation for your business, see useaifix.com.
Paperclip's Agent Orchestration Stack: How Multi-Agent Teams Track Work, Budgets, and Tool Permissions in Production Most multi-agent frameworks stop at message passing. Paperclip treats agent coordination as a company org chart problem: hierarchies, delegation rules, budget caps, and permission boundaries. The open-source stack (109K+ stars, Node.js server + React UI) positions itself as "the company" layer above individual agents. If OpenClaw is an employee, Paperclip is the HR system, finance department, and project management office rolled into one. This matters because production agent teams need the same operational infrastructure as human teams. You need to know which agent spent $47 on API calls yesterday, who delegated a task to whom, and why the content-generation agent can't access your database. Paperclip exposes primitives for these problems that most orchestration tools ignore. The Company Abstraction Paperclip's core metaphor is organizational structure. You define agents as team members, assign them skills, set budget limits, and track their work history. The system maintains an org chart that determines delegation paths and escalation rules. Key primitives: - Agent profiles: Each agent has a model selection (GPT-4, Claude, local LLM), a harness (the execution environment), and a skill set (allowed tools and actions). - Goal hierarchies: Top-level business goals decompose into tasks. Agents claim tasks based on skill matches and availability. - Budget tracking: Per-agent cost attribution for API calls, tool usage, and compute time. Hard caps prevent runaway spending. - Permission boundaries: Agents inherit permissions from their position in the org chart. A junior agent can't approve expenses or access production databases. The UI looks like a task manager. The backend is a state machine that routes work, enforces budgets, and logs every decision for audit trails. Architecture: Node.js Orchestrator + React Dashboard Paperclip runs as a Node.js server that manages agent state and a React frontend for human oversight. The server handles task assignment, budget enforcement, and tool permission checks. The UI shows real-time agent activity, cost breakdowns, and task progress. Component breakdown: | Component | Responsibility | State Persistence | |-----------|---------------|-------------------| | Orchestrator | Routes tasks to agents, enforces budget caps, checks permissions | PostgreSQL for task history, agent profiles, and audit logs | | Agent Harness | Executes agent code (local process, Docker container, or remote API) | Ephemeral; logs sent to orchestrator | | Skill Registry | Maps tool names to permission requirements and cost models | JSON config files, hot-reloadable | | Budget Tracker | Aggregates costs per agent, per task, per time window | Time-series database (InfluxDB or Prometheus) | | Audit Logger | Records every task assignment, delegation, tool call, and budget decision | Append-only log (S3 or local file) | The orchestrator maintains a task queue. When a new goal arrives, it decomposes into subtasks and assigns them to agents based on skill matches. If an agent hits its budget cap, the orchestrator pauses its tasks and escalates to a supervisor agent (or a human). Task Routing and Delegation Paperclip's task assignment uses a skill-matching algorithm. Each task declares required skills (e.g., "web scraping", "data analysis", "content generation"). Each agent declares available skills. The orchestrator finds the best match and assigns the task. Delegation rules: - Agents can delegate tasks to subordinates in the org chart. - Delegation requires explicit approval if the subordinate's budget cap is lower than the task's estimated cost. - Escalation happens automatically when an agent can't complete a task (missing skills, budget exhausted, or explicit failure signal). The system tracks delegation chains. If Agent A delegates to Agent B, who delegates to Agent C, the audit log shows the full path. This matters for debugging and cost attribution. Example delegation flow: // Simplified task assignment logic async function assignTask(task: Task, orgChart: OrgChart): Promise<Agent> { const candidates = orgChart.agents.filter(agent => agent.skills.includes(task.requiredSkill) && agent.budgetRemaining >= task.estimatedCost ); if (candidates.length === 0) { // Escalate to supervisor const supervisor = orgChart.getSupervisor(task.assignedTo); return assignTask(task, orgChart, supervisor); } // Pick agent with lowest current workload const selected = candidates.sort((a, b) => a.activeTasks.length - b.activeTasks.length )[0]; await logDelegation(task, selected); return selected; } Budget Tracking and Cost Attribution Every tool call, API request, and compute minute gets logged with a cost estimate. Paperclip aggregates these costs per agent, per task, and per time window. Budget caps are hard limits: when an agent exhausts its budget, the orchestrator pauses its tasks. Cost tracking flow: 1. Agent requests a tool call (e.g., "search web for competitor pricing"). 2. Orchestrator checks agent's remaining budget. 3. If budget allows, orchestrator estimates cost (based on tool's cost model) and reserves that amount. 4. Tool executes, returns actual cost. 5. Orchestrator updates agent's budget and logs the transaction. The system supports budget rollover (unused budget carries to next period) and budget pooling (team budget shared across agents). These are config options, not hardcoded policies. Budget enforcement table: | Scenario | Behavior | Escalation Path | |----------|----------|-----------------| | Agent under budget | Task proceeds normally | None | | Agent at 90% budget | Warning logged, task proceeds | Notify supervisor | | Agent at 100% budget | Task paused, no new assignments | Escalate to supervisor for budget increase or task reassignment | | Task exceeds agent's total budget | Task rejected at assignment time | Escalate to higher-tier agent or human | Permission Boundaries and Tool Access Agents inherit permissions from their org chart position. A junior agent can read from the knowledge base but can't write. A senior agent can approve expenses up to $500. A supervisor can access production databases. Permissions are declarative. Each tool declares required permissions (e.g., "database:write", "expense:approve"). Each agent has a permission set. The orchestrator checks permissions before allowing tool calls. Permission check example: // Before executing a tool call async function checkPermissions(agent: Agent, tool: Tool): Promise<boolean> { const requiredPerms = tool.requiredPermissions; const agentPerms = agent.permissions; const hasAllPerms = requiredPerms.every(perm => agentPerms.includes(perm)); if (!hasAllPerms) { await logPermissionDenial(agent, tool, requiredPerms); return false; } return true; } Permission violations get logged to the audit trail. Repeated violations trigger alerts. This prevents agents from accidentally (or maliciously) accessing resources they shouldn't touch. State Persistence and Audit Trails Paperclip persists agent state, task history, and audit logs to PostgreSQL. Long-running tasks survive server restarts. The audit log is append-only: every task assignment, delegation, tool call, budget decision, and permission check gets recorded with a timestamp and agent ID. Audit log schema (simplified): CREATE TABLE audit_log ( id SERIAL PRIMARY KEY, timestamp TIMESTAMPTZ NOT NULL, agent_id VARCHAR(255) NOT NULL, event_type VARCHAR(50) NOT NULL, -- 'task_assigned', 'tool_called', 'budget_exceeded', etc. task_id VARCHAR(255), tool_name VARCHAR(255), cost_cents INTEGER, permission_checked VARCHAR(255), metadata JSONB ); The audit log supports compliance requirements (who did what, when, and why) and debugging (why did this task fail? which agent made this decision?). You can query it to generate cost reports, permission violation summaries, or agent performance metrics. Multi-Tenant Considerations Paperclip supports multiple teams (tenants) on a single server. Each team has its own org chart, budget pool, and permission set. Agents in Team A can't see tasks or data from Team B. Isolation mechanisms: - Database-level row-level security (RLS) filters queries by tenant ID. - Agent harnesses run in separate processes or containers (Docker, Firecracker). - Tool calls include tenant context; tools enforce tenant boundaries. This matters for SaaS deployments or large organizations with multiple departments. You don't want the marketing team's agents accessing the finance team's data. Failure Modes and Observability Paperclip exposes metrics for agent health, task queue depth, budget burn rate, and permission denial rate. The dashboard shows real-time alerts when agents fail, budgets run low, or tasks stall. Common failure modes: - Agent crashes: Harness process dies. Orchestrator detects via health check, reassigns tasks to another agent. - Budget exhaustion: Agent hits cap mid-task. Orchestrator pauses task, escalates to supervisor. - Permission denial: Agent tries to call a tool it can't access. Orchestrator logs denial, returns error to agent. - Task timeout: Agent doesn't complete task within deadline. Orchestrator cancels task, reassigns to another agent. The system integrates with Prometheus for metrics and Grafana for dashboards. You can set up alerts for budget overruns, high permission denial rates, or task queue backlog. When to Use Paperclip Use Paperclip when: - You need to manage multiple agents with different skill sets and budget constraints. - You want audit trails for compliance or debugging. - You need permission boundaries to prevent agents from accessing sensitive resources. - You're running long-running workflows that span multiple sessions. Avoid Paperclip when: - You have a single agent or a simple pipeline (too much overhead). - You need real-time, low-latency coordination (the orchestrator adds routing latency). - You want to run agents in a fully decentralized way (Paperclip assumes a central orchestrator). Technical Verdict Paperclip solves the operational problems that emerge when you move from one-off agent demos to production multi-agent systems. The org chart abstraction is opinionated but practical: it maps cleanly to how organizations already think about delegation, budgets, and permissions. The stack is production-ready for teams that need cost control, audit trails, and permission enforcement. The Node.js + React architecture is straightforward to deploy and extend. The skill-matching and budget-tracking primitives are reusable building blocks. The main trade-off is centralization. The orchestrator is a single point of failure and a potential bottleneck. If you need fully decentralized agent coordination, look elsewhere. But if you're building a system where agents need to operate within organizational constraints (budgets, permissions, hierarchies), Paperclip exposes the plumbing you'll need. Source Links - Paperclip GitHub Repository - Paperclip Documentation - Paperclip Discord
Paperclip’s October release adds persistent agent files across tasks and support for syncing company skills from GitHub repositories. The interesting product question: how do teams keep shared agent instructions useful as they grow? github.com/paperclipai/paperclip/releases
Give your AI agents an org chart, budgets and a boss with Paperclip, the open-source way to run Claude Code, Codex and friends like a company 📎 🔗 paperclipai/paperclip Credits: paperclipai/paperclip #paperclip #typescript #aiagents
Meet Kowalski --- title: Meet Kowalski published: true description: A small team of AI agents on your own computer, on a free local model. You hand it a chore, it hands you a file. tags: opensource, rust, ai, localllm canonical_url: kowalski.yarenty.com cover_image: kowalski.yarenty.com --- October 2026 This post first appeared on the Kowalski blog. It's written for people who have never heard of Kowalski, so let's start at the beginning. Kowalski is a small team of AI agents that lives on your own computer and does chores for you. Not a chatbot you have to keep talking to, and not a platform you have to administer. You hand it a job, it does the job, and you get a file back. It's open source (MIT), written in Rust, and it runs on a free local model through Ollama, or on any hosted model with your own key. There are two well-known open-source projects in the same neighbourhood, and they help to explain what Kowalski is by what it isn't. OpenClaw is a personal assistant you chat with: it gets wide access to your machine and your apps, and it works best with a big frontier model behind it. Paperclip goes one level up: it runs a whole "company" of paid coding agents, with org charts, budgets and approvals. Both are impressive. Kowalski makes the opposite bet. Each job is a small, fixed pipeline you can read. The agents only touch the one folder you give them, and they ask before doing anything risky. The hard parts (fetching pages, running SQL, building spreadsheets) are ordinary code, so a small free model on a laptop is enough. The result is cheaper (€0 a run on a local model), more private (nothing leaves your machine), and easier to trust (every number comes from a query, not from the model's imagination). Penguins: no lobsters, no corporation. So what do you actually give it? A chore: a question about a spreadsheet, the five pages you read every morning, a document that just landed in your inbox, a topic to research. Kowalski hands the chore to a horde, a short pipeline of specialised agents we call penguins, and gives you back something you can use: a report workbook, a one-page brief, a note in your Obsidian vault. !A first run of kowalski: install, Setup, connect tableski, drop a workbook, get answers What it does today Five hordes come with it:h - Spreadsheet analyst. Ask questions about your workbooks in plain words and get a report workbook back. The model writes the SQL; every number comes from a query engine, never from the model. - Morning brief. The pages you follow, read for you: the few items worth your time, why each matters to you, and the link. It can run every weekday at 7:00. - Folder watcher. Drop a document into its inbox and get a note: what it is, the key facts, and what to do by when. - Knowledge compiler. Ask a question and list the pages that should answer it. You get one note with its sources, saved straight into your Obsidian vault. - URL summarizer. A list of links in, a short summary of each out. A horde is a folder of plain Markdown files, so you can read exactly what each penguin is told, copy one and change it, or have kowalski build a new one with you. How it got here Kowalski started on 4 March 2025 as a weekend experiment: a Rust program that could talk to a local Ollama model. Here's the short version of what happened next. - 2025: big plans. By the summer it had a five-layer architecture, a crate per agent, three databases and a federation layer for a distributed system nobody was running. It was a good exercise and a bad product: nothing in it could be handed to someone who doesn't write Rust. - Early 2026: smaller. 1.0 deleted most of that on purpose. One agent type instead of many crates, SQLite instead of three databases, an HTTP server and a web UI, and tools reached through MCP. - Spring 2026: hordes. The idea that gave the project its shape: a pipeline as a folder of Markdown. Builders, graphs with loops, then triggers (cron, file watch, webhook) and durable runs that survive a restart. - September 2026: the product. One binary with the UI inside, a three-question Setup, ready-made hordes, and data steps that keep numbers out of the model. Since 2.5: a signed Mac app you install by dragging it to Applications. Eighteen months and more than 700 commits later, the pattern is clear: almost every good change removed something. The long version of that story is Eighteen months of Kowalski. Who it's for People with recurring chores and data they'd rather keep on their own machine: a small business owner with a sales workbook, an engineer who reads the same five sites every morning, a researcher whose notes live in Obsidian. If you write code, a horde is a folder you can version, review and share. Try it On a Mac, download Kowalski.dmg, drag it to Applications and open it. On a Mac or Linux, from a terminal: curl -fsSL https://raw.githubusercontent.com/yarenty/kowalski/main/install.sh | bash kowalski Your browser opens on Setup: pick a model, a folder, and optionally your tableski account. Then pick a horde and send it in. Everything is at yarenty/kowalski. If something goes wrong, open an issue. Kowalski does the analysis; I do the apologising. And if everything works first time, just smile and wave, boys. Smile and wave. 🐧 Originally published on the Kowalski blog.
Paperclip’s latest release adds private agent tasks, persistent identities, external model gateways and more detailed cost accounting. paperclipai/paperclip
한 달에 ★45,470 붙은 GitHub 저장소의 정체 (10월 트렌딩 TOP 5) 이번 달 GitHub 트렌딩(월간)에서 스타가 가장 많이 늘어난 저장소 5개를, 뭘 하는 건지·왜 뜨는지까지 설명합니다. 0:00 한 달에 스타 4만 5천 개가 붙은 저장소? 0:10 5위 ai-engineering-from-scratch 0:28 4위 ECC 0:50 3위 paperclip 1:12 2위 hindsight 1:33 1위 VoiceStudio 1:55 한 줄 정리 ■ 이번 영상의 저장소 5위 rohitg00/ai-engineering-from-scratch 4위 affaan-m/ECC 3위 paperclipai/paperclip 2위 vectorize-io/hindsight 1위 debpalash/VoiceStudio ■ 데이터 기준 - 순위·이번 달 증가 스타: GitHub 트렌딩(monthly) 2026-10-21 스냅샷. 증가량은 트렌딩 페이지 값이며 별도로 검증하지 못했습니다. - 총 스타·라이선스·설명: GitHub API 2026-10-21 확인. - "개발사 주장"과 "제 해석"은 영상에서 구분해 표시했습니다. hindsight의 LongMemEval 91.4%는 개발사가 논문에 밝힌 자체 결과입니다. - 스타 수는 품질을 보장하지 않습니다. - VoiceStudio는 AGPL-3.0 라이선스입니다. 상업적으로 쓰기 전에 직접 확인하세요. ■ 음성 내레이션은 AI 음성(Gemini TTS)입니다. #GitHub #깃허브 #GitHub트렌딩 #오픈소스 #AI에이전트 #개발자 #AI개발
7 GitHub Repos That Feel Illegal to Know (October 2026) Seven open-source projects exploding on GitHub right now: a free voice-cloning studio, PS5 games running natively on PC, an AI agent that got its creator hired, free AI models from 34 providers, directed AI filmmaking, videos rendered from code, and a "company" made of AI agents. What each one does, who it helps, and the catch. 0:00 Seven repos, 120K+ new stars 0:32 #1 VoiceStudio: free, local voice cloning 1:38 #2 AnyPS5: PS5 games on PC, no emulator 2:41 #3 AI Job Search: the agent that got its creator hired 3:35 #4 FreeLLMAPI: 34 free AI providers, one API 4:20 #5 ArtCraft: direct your AI shot 5:00 #6 HyperFrames: write HTML, get a video 5:44 #7 Paperclip: a company of AI agents 6:20 Bonus: REA 6:48 Recap Repos (star counts as of Oct 20, 2026) VoiceStudio: debpalash/VoiceStudio AnyPS5: boykopovar/AnyPS5 AI Job Search: MadsLorentzen/ai-job-search FreeLLMAPI: tashfeenahmed/freellmapi ArtCraft: storytold/artcraft HyperFrames: heygen-com/hyperframes Paperclip: paperclipai/paperclip REA: morluto/rea Only clone voices you have permission to use. AnyPS5 needs your own legally dumped games. Beware fake installers for AnyPS5 and REA: use the official repos above. Demo footage and screenshots are from each project's README, used for commentary. Narration uses an AI voice.
Benchmarking Paperclip Agent Orchestration: Concurrent Task Throughput and Memory Overhead Under Load Benchmarking Paperclip Agent Orchestration: Concurrent Task Throughput and Memory Overhead Under Load When evaluating paperclipai/paperclip for production agent orchestration, I needed concrete performance data under realistic multi-user concurrency. Here's what I measured and where the architecture holds up. Test Topology Environment: - Next.js 15.2 app router with React Server Components - 4-core, 8GB VPS (DigitalOcean) - PostgreSQL 16 with connection pooling (pgBouncer, 20 max connections) - k6 load generator simulating 50 concurrent users Scenario: Each virtual user triggers a multi-step agent workflow: 1. Create new task via Server Action 2. Agent processes task (calls LLM via B-Lost relay gateway at https://b-lost.com/v1) 3. Stream incremental results back to UI via Suspense boundaries 4. Update task status in database Code Configuration: // app/actions/agent-task.ts 'use server' import { z } from 'zod' import { auth } from '@/lib/auth' const TaskSchema = z.object({ prompt: z.string().min(10).max(2000), agentId: z.string().uuid(), }) export async function createAgentTask(data: z.infer<typeof TaskSchema>) { const session = await auth() if (!session) throw new Error('Unauthorized') const validated = TaskSchema.parse(data) // Paperclip agent dispatch const response = await fetch('https://b-lost.com/v1/chat/completions', { method: 'POST', headers: { 'Authorization': `Bearer ${process.env.BLOST_API_KEY}`, 'Content-Type': 'application/json', }, body: JSON.stringify({ model: 'claude-sonnet-4', messages: [{ role: 'user', content: validated.prompt }], stream: true, }), }) return response.body // Stream to client } // k6-load-test.js import http from 'k6/http' import { check, sleep } from 'k6' export const options = { stages: [ { duration: '2m', target: 50 }, { duration: '5m', target: 50 }, { duration: '2m', target: 0 }, ], } export default function () { const payload = JSON.stringify({ prompt: 'Analyze this dataset and extract key metrics', agentId: '550e8400-e29b-41d4-a716-446655440000', }) const res = http.post('https://test-instance.com/api/agent-task', payload, { headers: { 'Content-Type': 'application/json' }, }) check(res, { 'status 200': (r) => r.status === 200, 'response < 2s': (r) => r.timings.duration < 2000, }) sleep(1) } Metric Comparison Table | Metric | Cold Start (0 active tasks) | Steady State (50 concurrent) | Peak Load (80 concurrent) | |--------|----------------------------|------------------------------|---------------------------| | Avg Response Time | 420ms | 680ms | 1,240ms | | p95 Latency | 580ms | 950ms | 1,850ms | | p99 Latency | 720ms | 1,340ms | 2,680ms | | Throughput (RPS) | 12.4 | 48.2 | 52.1 | | Memory Consumption | 340MB | 780MB | 1,120MB | | Database Connection Pool Saturation | 8% | 42% | 78% | Key Observations: 1. RSC Streaming Holds Up Well: Even at p99, initial content rendered within 1.4s at steady state. Suspense boundaries prevented waterfall blocking. 2. Database Connection Pool Becomes Bottleneck: At 80 concurrent users, pgBouncer hit 78% saturation. Tasks queued for available connections, spiking p99 to 2.68s. 3. Memory Growth is Linear: paperclipai/paperclip's agent state management scaled predictably—no memory leaks observed over 30-minute sustained load. 4. B-Lost Gateway TTFT Consistency: When routing LLM requests through B-Lost's relay at https://b-lost.com/v1, time-to-first-token remained stable (median 380ms) with automatic fallback to backup providers during two brief Claude API timeouts. Production Threshold For teams evaluating paperclipai/paperclip: Adopt if: - You need coordinated multi-agent workflows with >20 concurrent users - Your database can handle connection pooling (recommend 2x expected peak concurrency) - You're already using Next.js App Router and want native RSC streaming Avoid if: - Your workload is <10 users with simple single-shot LLM calls (overhead isn't justified) - You need sub-200ms p99 latency for agent responses (requires distributed task queue like BullMQ) Configuration Adjustments: To push beyond 80 concurrent users without latency degradation: // Increase pgBouncer pool size // config/database.ts export const poolConfig = { max: 40, // Up from 20 idleTimeoutMillis: 10000, connectionTimeoutMillis: 3000, } // Add Redis-backed task queue for async agent jobs import { Queue } from 'bullmq' const agentQueue = new Queue('agent-tasks', { connection: { host: 'localhost', port: 6379 }, }) The architecture remains sound—paperclipai/paperclip's design with React Server Components and Server Actions provides clean separation between UI and agent orchestration logic. At our measured throughput of 48 RPS under realistic load, the Next.js runtime handled concurrent agent state without custom locking or race conditions. For latency-sensitive production deployments, pair with a proper task queue and scale database connections proportionally. The framework itself won't be your bottleneck until you're well past 100 concurrent agent workflows.