Agency Core: Turn Any Server into a Private AI Team's Autonomous Agent Platform

Agency Core is a self-hosted autonomous AI platform that can turn any server (laptop, VPS, GPU server) into a private AI team. It has a built-in CEO coordination agent and multi-domain expert agents, supporting engineering tasks like code writing, PR management, and test execution. Also, as an OpenAI-compatible agent for Ollama, it allows tools such as Cursor and Aider to use local models. This project is maintained by strikersam, with source code hosted in the GitHub repository local-llm-server, released on June 1, 2026. Its core value lies in solving pain points of current AI tools like data privacy issues, cost explosion, and workflow fragmentation, enabling true end-to-end automated collaboration.

Current mainstream AI tools have six major pain points:

1. Data Privacy Dilemma: Sensitive code needs to be uploaded to third-party servers, which is high-risk;
2. One-time Answer Limitation: Only provides one-time answers and cannot work continuously;
3. Tool Fragmentation: Multiple tools require multiple accounts/keys, making management complex;
4. Insufficient Git Integration: Most AI agents cannot truly submit code or initiate PRs;
5. Lack of Observability: No tracking of decision-making processes;
6. Cost Explosion: Cloud-based token-based billing leads to sharply increasing costs as scale grows.

Agency Core addresses these issues specifically: All operations run locally (privacy), supports continuous workflows (e.g., full PR cycle), unified platform management (reduces fragmentation), complete Git integration, built-in Langfuse observability, and marginal cost is only electricity fees.

Agency Core's AI team has three categories of capabilities: Engineering Agents:

• Bug Fixing: Analyze issues → Write code → Initiate PR → Monitor CI → Wait for approval;
• Dependency Audit: Scan CVE → Create security upgrade PR;
• Code Review: Check for security vulnerabilities, N+1 queries, etc.;
• Test Generation: Write unit/integration tests;
• Refactoring: Identify technical debt → Execute refactoring;
• Release Management: Version number upgrade, change log, tagging;
• Documentation Maintenance: Sync code with API/architecture documents.

Content & Knowledge Agents:

• Write product descriptions, blogs;
• Update knowledge base when code changes;
• Summarize GitHub issues/Slack threads;
• Automatically generate weekly summaries.

Operations Agents:

• Monitor CI pipelines and alert on anomalies;
• Manage scheduled tasks (daily summaries, weekly audits);
• Intelligent model routing;
• Real-time health diagnosis.

Deployment and usage are divided into six steps:

1. Startup Activation: Deploy via Docker/Render/uvicorn, run the setup wizard (connect to Ollama/cloud provider, generate API key, create admin account, pull models like qwen2.5-coder:7b, health check);
2. Describe Company: Enter repository URL, fill in tech stack, team size, etc., to build a knowledge graph;
3. Converse with CEO Agent: Describe requirements in natural language (e.g., fix issue#142), CEO decomposes tasks → Delegate to experts → Return PR link/result;
4. Monitor Task Board: View task status (queued→planning→executing→verifying→awaiting approval→done), click to see plans, steps, test results;
5. Manual Approval Gate: Key operations (code merging, production deployment) require manual approval; supports configuring auto-approval for low-risk operations;
6. Schedule Regular Work: Set cron tasks (daily PR summary, weekly CVE audit, document sync when code is merged, etc.).

Tool Integration: As an OpenAI-compatible agent, it seamlessly connects to tools like Cursor, Continue, Aider, and Claude Code. Simply point to http://localhost:8000 to use local models.

Real-World Scenarios:

1. Automated Bug Fixing: Issue → Analysis → Code → PR → CI → Notify review;
2. Continuous Code Quality Monitoring: Weekly scan for technical debt, security vulnerabilities → Generate report → Auto-PR for low-risk refactoring;
3. Document Sync: Automatically update API documents and architecture records when code is merged.

Competitive Advantages:

Dimension	Agency Core	Traditional Cloud AI Tools	Other Open-Source Agent Frameworks
Data Privacy	Fully Local	Need to Upload to Cloud	Depends on Implementation
Cost Model	Marginal Cost = Electricity	Token-Based Billing	Requires Self-Built Infrastructure
Git Integration	Full PR Lifecycle	Only Code Suggestions	Inconsistent Features
Observability	Built-in Langfuse	Limited/Extra Charge	Need Self-Integration
Human-Machine Collaboration	Approval Gate Mechanism	Lack of Workflow Control	Requires Extensive Customization
Deployment Flexibility	Local/Cloud/Hybrid	Cloud-Only	Requires Technical Expertise

Summary: Agency Core is a milestone in AI-assisted development, combining LLM capabilities with software engineering practices to solve core pain points like privacy and cost. For teams that value data security, it provides a controllable and efficient AI collaboration platform, which will become an intelligent collaboration partner in the future.