Scientific research
Review literature, compare hypotheses and support reproducible experiments. Keep methods, sources and results connected.
A blueprint for open-source AI agent teams
Your mission.
Your open-source AI team.
Cognidamesh is a blueprint for building your own open-source AI agent teams for scientific research, OSINT, pentesting, countering disinformation, and administrative and financial management. It maps the essential capabilities, the components to choose and how they fit together.
AN AI TEAM BLUEPRINT · OPEN SOURCE · SELF-HOSTED
TEAM BLUEPRINT / 001● HUMAN-DIRECTED
SHARED MISSIONTurn information into knowledge
ResearchDiscover
BuildDeliver
OperateMaintain
⊞ Organisational memoryHINDSIGHT
ILLUSTRATIVE TEAMONE MISSION. SHARED CONTEXT.
Capabilities first. Components second.PaperclipHermesHindsightSearXNGCamofoxPodman
01 / What these teams are for
Investigate. Understand.
Build knowledge together.
A shared foundation for different missions. These are the uses the blueprint aims to enable; each team brings its own expertise, data and specialist tools.
OSINT
Collect public information, cross-check sources and build documented investigations with traceable evidence.
Pentesting
Coordinate authorised security assessments, analyse findings and organise remediation within a defined scope.
Countering disinformation
Trace claims to their sources, compare accounts and document contradictions and uncertainty for human review.
Administrative management
Sort documents, prepare correspondence, track cases and deadlines, and coordinate internal workflows. Keep access scoped to each role and have people validate official submissions.
Financial management
Support investment management in stock markets and cryptocurrencies: monitor markets and portfolios, compare performance and prepare investment decisions. Prepare budgets, reconcile invoices and transactions, track cash flow and flag discrepancies. Keep supporting records traceable and require human approval for payments and financial commitments.
02 / The building blocks
Start with the function.
Then choose the brick.
A blueprint for assembling your own stack, rather than a ready-to-install code distribution. Each block presents a function, recommended components and alternatives. The goal remains a 100% open-source foundation; proprietary and hosted options are identified.
01Coordinate
Team orchestration
Give the team goals, roles and a shared work queue. Delegate tasks, organise hand-offs and keep people in charge of priorities.
MISSION → ROLES → TASKSComponents & alternatives
Paperclip provides the organisational layer that brings individual agents into a team.
02Execute
Agent execution
Turn a mission into actions through tools and skills. Choose a runtime for each role and connect it to the orchestrator through an adapter.
ONE TEAM, COMPLEMENTARY RUNTIMESComponents & alternatives
Hermes is our main choice for knowledge work. OpenCode, pi and Codex CLI are open-source coding options. Claude Code and Bob Shell are proprietary alternatives, connected through the available adapters.
03Remember
Memory management
Keep findings, sources, decisions and context across sessions. Agents need to retrieve useful knowledge and build on what their team has already learned.
RETAIN → RECALL → REFLECTComponents & alternatives
Hindsight is currently the best fit for our blueprint: retain, recall and reflect operations, with a dedicated memory bank per organisation.
04Investigate
Search & collection
Find information, read web pages and follow evolving sources. Feed the team relevant material with its provenance.
SEARCH → READ → CROSS-CHECKComponents & alternatives
SearXNG provides self-hosted search; Camofox and CloakBrowser support browsing and collection. Tavily offers a hosted search and extraction API. CloakBrowser’s wrapper is MIT, but its binary has separate terms: these options are not all fully open source.
05Reason
Model serving & routing
Supply the models that agents use to reason, handle routine tasks and create embeddings. Keep the inference layer under your control.
SELF-HOSTED INFERENCEOptions to evaluate
vLLM and TensorFold are inference engines to evaluate against your models and hardware. The open-source LiteLLM core provides API routing. Check model formats, memory requirements and compatibility with the agent runtimes.
Abliterated models
These variants, sometimes called “obliterated”, modify model weights to reduce or remove certain learned refusal behaviours, including restrictions that may censor legitimate requests. Abliteration targets refusal-related directions in the model’s internal representations; it does not guarantee the removal of every restriction or bias. Fewer refusals do not guarantee accuracy or stronger capabilities: evaluate answer quality and tool use. The base model’s licence still applies.
Security belongs in the harness
The harness — the software that controls the agent’s execution — must enforce security outside the LLM. Add an independent guardrail that assesses the intent and context of requests before execution, then checks proposed actions and tool calls against the user’s permissions and authorised scope. Allow, block or escalate accordingly. Combine this with least-privilege access, sandboxing, audit logs and human approval for sensitive actions. Intent analysis can make mistakes: it complements enforced permissions and isolation, and must not be the only defence.
Example model card ↗06Run
Portable execution
Run services with explicit permissions, networking and persistent storage. Reproduce the environment on a server, VM or in containers.
YOUR ENVIRONMENT, YOUR CONTROLComponents & alternatives
Podman and Quadlet suit a single host; Kubernetes orchestrates containers across a cluster, while OpenShift provides an integrated Kubernetes platform. Terraform defines and provisions infrastructure; Ansible configures systems. Current Terraform releases use the BSL; OpenTofu is the open-source alternative.
07Specialise
Skills & methods
Give agents a coherent set of capabilities: reusable instructions, procedures, tools and validation criteria. Select skills per role and adapt them to the team’s runtime, sources and field.
METHOD → EXECUTION → VALIDATIONComponents & alternatives
BMAD structures software delivery, from planning through architecture and implementation. Strix is an agentic pentesting tool with skills for running assessments, addressing findings and verifying fixes. Curate a set for your mission; formats, tool requirements and integrations vary by runtime.
08Adapt
LLM retraining & fine-tuning
Adapt a model to your domain, vocabulary and tasks using curated training examples. Keep training separate from production inference.
DATA → TRAIN → EVALUATE → DEPLOYComponents & alternatives
Unsloth supports LLM fine-tuning, including LoRA and QLoRA for supported models. Check model and GPU compatibility, dataset rights and model licences. Version datasets and adapters, compare against the base model on a held-out evaluation set, then export to a compatible inference engine. Recheck tool use and harness guardrails before deployment; fine-tuning and abliteration serve different purposes.
03 / How the pieces connect
See the connections.
Read each block as a capability, then as a component choice. This is an assembly map for your future team.
Coordination & executionKnowledge & services→ Arrows show integration paths
Functional map: validate connections for each runtime. Hermes carries the blueprint’s research and memory integrations. Search, inference and hosting alternatives are detailed in the blocks; they are not all required or all open source. BMAD and Strix skills connect according to supported formats and tools.
Inspect the Mermaid source
flowchart TB
accTitle: Cognidamesh open-source blueprint
accDescr: Functions and components for assembling an open-source AI team.
H["Mission and human direction"] --> P["Orchestration · Paperclip"]
P --> R["Execution and research · Hermes"]
P --> C["Coding · OpenCode, pi, Codex CLI, Claude Code, Bob Shell"]
P -->|activity| M["Memory management · Hindsight"]
R <--> M
R --> W["Search and collection · SearXNG, Camofox, CloakBrowser, Tavily"]
R --> G["Inference · vLLM, TensorFold, LiteLLM"]
C --> G
M --> G
S["Skills and methods · BMAD, Strix"] -.-> R
S -.-> C
subgraph F["Containers / clusters"]
P
R
C
M
W
G
S
end
classDef lead fill:#d5f879,stroke:#8fa54f,color:#19281f,stroke-width:1px;
classDef core fill:#263c2e,stroke:#476345,color:#ffffff,stroke-width:1px;
classDef service fill:#e9efdf,stroke:#b3c49d,color:#263c2e,stroke-width:1px;
classDef data fill:#ffffff,stroke:#a6b993,color:#263c2e,stroke-width:1px;
class H,P lead;
class R,C core;
class W,G,S service;
class M data;
style F fill:#f9faf4,stroke:#b3c49d,stroke-dasharray:5 5,color:#476345;
04 / Choose your agent runtimes
A choice of runtimes.
Complementary skills.
The runtime is the agent’s execution engine. Assemble a team using the open-source clients or proprietary alternatives below, then add the tools and skills each role needs.
Research & knowledge
Hermes
Our primary runtime for knowledge work: combine research skills, web tools and Hindsight memory. Use separate profiles for agents and a dedicated container for each organisation.
Research · tools · durable memoryFor a 100% open-source team, select runtimes, services and models with licences that meet that goal. Claude Code and Bob Shell are optional proprietary alternatives. A client’s licence does not determine the model’s licence; downloadable weights alone do not make a model open source.
05 / Put the blueprint into practice
From an idea to a team.
Follow the capabilities in order. Start with a small, useful team and expand from evidence.
Define the mission
Choose the research question, investigation or assessment. Specify roles, expected outputs and what people must review.
Choose the components
Select an orchestrator, runtimes and a model stack. Check licences, hardware needs and API compatibility.
Connect tools, skills & memory
Curate the skill set, using BMAD for software delivery or Strix for assessments, then connect sources and memory. Verify evidence preservation, context retrieval and results.
Evaluate & improve
Test on representative tasks, review quality and document what works. Revisit the component choices as the ecosystem evolves.
06 / Run it on your terms
Your stack.
Your environment.
Start on a server or VM with Podman, or distribute services across Kubernetes or OpenShift. Define infrastructure with Terraform or OpenTofu, then configure systems with Ansible.
AN ACCESSIBLE STARTING POINT
Start with a Linux environment.
Bring together the orchestrator, agent runtimes, tools and memory. Size CPU, RAM, storage and optional GPUs around the models and workloads you choose.
LinuxServer or VMYour hardware
This architectural blueprint evolves with the ecosystem. Validate the recommended components against your own workloads.
07 / FROM BLUEPRINT TO YOUR INFRASTRUCTURE
Want the same architecture?
Copy and paste this into your favourite AI coding agent.
Read https://cognidamesh.org/agents.md and use it to build, test and deploy a similar AI infrastructure in my project. Respect existing project instructions; ask me only for missing requirements, access and deployment approvals.The linked AGENTS.md is a public implementation guide in the open Markdown format. Your agent will adapt it to your project, hardware and access. If it cannot read the URL, download the guide and attach it to your request.