1
import google.generativeai as genai
2

3
# State persists in the 'chat' history object
4
def call_agent(role, task, history=None):
5
    model = genai.GenerativeModel('gemini-1.5-pro', system_instruction=role)
6
    chat = model.start_chat(history=history)
7
    return chat.send_message(task).text, chat.history
8

9
def network_audit(code):
10
    # Stage 1: Auditor
11
    report, history = call_agent("Security Auditor", f"Audit: {code}")
12

13
    # Stage 2: Surgeon (Passes the Auditor's history as context)
14
    final_code, _ = call_agent("Refactor Surgeon", "Fix based on previous audit", history)
15
    return final_code
16

17
# Trigger the Swarm
18
target_code = "def insecure_func(data): exec(data)"
19

20
print("Mission Start: Dispatching Swarm...")
21
optimized_logic = perform_network_audit(target_code)
22

23
print("\n--- Final Sovereign Output ---")
24
print(optimized_logic)
25
print("Mission Success: Sovereign State maintained.")

1
import { GoogleGenerativeAI } from "@google/generative-ai";
2

3
async function runSwarm(code) {
4
    const genAI = new GoogleGenerativeAI(process.env.GEMINI_API_KEY);
5

6
    // Agent 1: Auditor
7
    const auditor = genAI.getGenerativeModel({
8
        model: "gemini-1.5-pro",
9
        systemInstruction: "You are a Security Auditor."
10
    });
11
    const auditRes = await auditor.generateContent(`Audit this: ${code}`);
12
    const report = auditRes.response.text();
13

14
    // Agent 2: Surgeon (Uses Audit report as input)
15
    const surgeon = genAI.getGenerativeModel({
16
        model: "gemini-1.5-pro",
17
        systemInstruction: "You are a Refactor Surgeon."
18
    });
19
    const finalRes = await surgeon.generateContent(`Fix this code using this report: ${report}\nCode: ${code}`);
20
    return finalRes.response.text();
21
}
22

23
// Trigger the Swarm
24
const targetCode = "function risky(input) { eval(input); }";
25

26
console.log("Mission Start: Dispatching JS Swarm...");
27

28
runSwarm(targetCode)
29
    .then(optimizedLogic => {
30
        console.log("\n--- Final Sovereign Output ---");
31
        console.log(optimizedLogic);
32
        console.log("Mission Success: Sovereign State maintained.");
33
    })
34
    .catch(err => console.error("Swarm Failure:", err));

1
import dev.langchain4j.service.AiServices;
2
// Using LangChain4j 'AiServices' makes multi-agent handoffs seamless
3

4
public class SwarmController {
5
    interface Auditor { String audit(String code); }
6
    interface Surgeon { String refactor(String report, String code); }
7

8
    public static void runAudit(String code) {
9
        Auditor auditor = AiServices.create(Auditor.class, model);
10
        Surgeon surgeon = AiServices.create(Surgeon.class, model);
11

12
        // The Handshake
13
        String report = auditor.audit(code);
14
        String fixedCode = surgeon.refactor(report, code);
15

16
        System.out.println("Swarm Final Output: " + fixedCode);
17
    }
18
}
19

20
public static void main(String[] args) {
21
    String targetCode = "public void run(String cmd) { Runtime.getRuntime().exec(cmd); }";
22

23
    System.out.println("Mission Start: Dispatching Java Swarm...");
24

25
    // In Java, the Controller orchestrates the handoff
26
    runAudit(targetCode);
27

28
    System.out.println("Mission Success: Sovereign State maintained.");
29
}