# Tony: Security. Systems. Software. Source: https://satunix.github.io/site/ Offensive security and security engineering. I work across penetration testing, adversary simulation, cloud infrastructure and autonomous AI systems. Most of my time sits on the boundary between offensive operations and engineering: testing systems, and building the infrastructure, tooling and telemetry that the testing depends on. Increasingly that means the security of AI agents themselves: what they are allowed to do, and how you stop them doing the rest. ## Key information - role: senior consultant, offensive security - based: Brisbane, AU - focus: adversary simulation, cloud, AI agents - stack: Python, Go, C, AWS, Azure, Linux - lab: private GitLab + AWS - status: not open to work ## Areas - [Offensive Security](https://satunix.github.io/site/work.md): Penetration testing and adversary simulation across networks, Active Directory, cloud and APIs. - [Security Engineering](https://satunix.github.io/site/work.md): The infrastructure behind the testing: C2, telemetry pipelines, GitOps, tooling and platforms. - [AI Systems](https://satunix.github.io/site/projects.md): Securing autonomous agents, and building constrained agent systems in a private lab. --- # Work Source: https://satunix.github.io/site/work/ Representative of work carried out repeatedly, across many engagements and organisations. No entry describes a specific client: each is a type of work, summarised from many instances of it. ## Cloud assumed-breach assessments Starting from an already-compromised workload and asking how far an attacker could get from there: which identities it can reach, which trust relationships it can abuse, and what it would take to stop them. Covers: - identity and instance-metadata enumeration - role assumption and privilege-escalation paths - lateral movement and cross-account trust - configuration weaknesses along the attack path - evidence-driven remediation guidance ## Internal network and Active Directory testing Internal penetration testing of Windows domain environments, following credential and trust relationships the way a real intruder would. Covers: - domain enumeration - Kerberos attack paths - Active Directory Certificate Services - credential and trust relationships - privilege escalation and lateral movement - controlled command-and-control activity ## Cloud security configuration reviews Reviewing AWS environments for the configuration choices that decide how bad a compromise becomes, with automation where the checks repeat. Covers: - IAM design and permissions - instance metadata (IMDSv2) and STS - storage and network controls - benchmark-aligned review and automation ## API and application security Assessing web applications and APIs, including cloud API gateway deployments, with attention to where one trust boundary quietly depends on another. Covers: - authentication and authorisation - API exposure and gateway configuration - trust boundaries between services - application and API attack paths ## Agentic AI security assessments Assessing deployments of AI agents and the environments around them. The recurring question: what can the agent actually do, and who decided it should be able to? Covers: - excessive tool authority - privilege escalation through agent actions - sensitive-data exposure and exfiltration paths - access control around agents and their tools - monitoring, governance and deployment configuration ## Phishing simulation platform engineering Designing, building and operating an offensive-security platform end to end, used across many simulation campaigns: front end, telemetry, cloud infrastructure, deployment and observability in one system. Covers: - custom landing pages and client-side telemetry - telemetry API and schema design - cloud-hosted infrastructure - GitOps and CI/CD deployment - log ingestion and dashboards - campaign operations and troubleshooting --- # Projects Source: https://satunix.github.io/site/projects/ Personal research and experiments, separate from client work. Most of it lives in a private lab (self-hosted GitLab and AWS) and changes constantly. GitHub holds a small public subset: things that have been pulled out of the lab on purpose, sometimes in rougher shape than the versions still running privately. GitHub: https://github.com/satunix ## SOAR: dynamic delegation _Letting agent topology follow the problem._ (status: research) An agent receives a goal and a plan, decides whether it can finish the work as one unit, and otherwise decomposes it and delegates the parts to specialised workers, recursively. No fixed org chart of agents: structure forms around the task. Themes: - recursive task decomposition - dynamic subagent formation - context routing and task-local memory - recovery when workers fail - verification of completed work - long-horizon reliability ## Autonomy Gate _Controlling what tool-using agents are allowed to do._ (status: ongoing) A control layer between an agent and its tools: explicit allow and deny, approval-required actions, and a policy evaluator that reconstructs what the user actually asked for before judging a tool call. Tested against real failure cases, including an action that executed before the approval prompt showed it as authorised. Themes: - allow / deny / approval-required actions - LLM-based policy evaluation - user-goal reconstruction - human-in-the-loop approval - prompt-injection and context-poisoning resistance ## Evidence-first pentest agents _Every finding resolves back to evidence._ (status: research) A local-first design for AI-assisted penetration testing in which scope is enforced deterministically, every tool runs through a governed adapter, and every conclusion links to append-only evidence. Built to support human testers, not replace them. Themes: - deterministic scope and rules-of-engagement enforcement - typed approvals and governed tool adapters - append-only evidence - injection and tool-poisoning resistance - false-positive handling - evidence-linked reporting ## Governed cyber lab _Agents that improve against benchmarks, inside hard limits._ (status: experiment) A research environment where agents, tools and workflows are evaluated and improved against benchmarks while staying constrained: short-lived least-privilege workers, verifiers kept separate from doers, and human approval for anything that touches the real world. Themes: - orchestrator / worker architecture - ephemeral least-privilege workers - benchmark-driven evaluation - verifier separation - signed scope and rules of engagement ## Private AI infrastructure _Local and self-hosted inference for agent work._ (status: ongoing) Running models locally and in private cloud to back agent systems: what fits in memory, what it costs, and which numbers actually matter for interactive work. Themes: - llama.cpp / llama-server and vLLM - quantisation and context scaling - concurrency, TTFT and throughput - prefix caching and CPU offload - Intel GPU inference - cloud serving and cost / performance ## Smaller builds _Tools and systems from the lab._ (status: assorted) A small POSIX C99 system-information utility (Minifetch), a libp2p / QUIC secure-access prototype, home automation on Home Assistant and Zigbee, and self-hosted service orchestration for the lab itself. Themes: - C99 - libp2p / QUIC - Home Assistant - homelab infrastructure Link: https://github.com/satunix --- # CV: Tony Source: https://satunix.github.io/site/cv/ Offensive security professional working in security since 2021, across penetration testing, adversary simulation and security engineering. I build the infrastructure, tooling and telemetry that support offensive work, and increasingly focus on the security of AI and autonomous agent systems. Not currently open to new roles. ## Experience - 2026 H2 - present: Senior Consultant, Offensive Security - 2025 H2 - 2026 H1: Consultant, Offensive Security - 2025 H1: Consultant, Tech Risk and Cyber - 2024: Graduate, IT Audit ## Capabilities - Internal and external network penetration testing - AWS and Azure security testing; cloud IAM and trust-path analysis - Web application and API security assessments - Active Directory, Kerberos and AD CS testing - Phishing and social-engineering simulation - External attack-surface analysis and OSINT - Adversary simulation; offensive infrastructure and C2 engineering - Custom security tooling and automation; CI/CD and GitOps - Detection and telemetry engineering - Security architecture and threat modelling - AI and agentic-system security testing - Technical reporting and remediation guidance ## Credentials - eJPT (INE Security): 2025 - AZ-500 (Microsoft): in progress - CS50 (Harvard): in progress - CPTS (Hack The Box): in progress - OSCP (OffSec): in progress ## Skills - Security: Burp Suite, Active Directory, Kerberos, AD CS, web and API testing, phishing, OSINT, adversary simulation, cloud attack paths, IAM, C2 infrastructure - Cloud / infra: AWS (EC2, IAM, STS, S3, EBS/EFS), Azure, containers, Kubernetes, GitOps, CI/CD, Linux - Engineering: Python, Go, C (C99), Bash, PowerShell, Git, GitHub Actions, APIs, telemetry pipelines - AI / LLM: local LLM infrastructure (Ollama, llama.cpp, vLLM), model serving, tool-using agents, MCP-style tooling, agent orchestration, RAG and vector stores, AI security evaluation --- # Links Source: https://satunix.github.io/site/links/ - GitHub: https://github.com/satunix - Gravatar: https://gravatar.com/satunix - RSS: https://satunix.github.io/site/rss.xml --- # Writing Source: https://satunix.github.io/site/blog/ - [Why more agent autonomy creates a security architecture problem](https://satunix.github.io/site/blog/agent-autonomy-is-a-security-architecture-problem.md) (2026-09-23, draft): Authority, delegation, trust boundaries and least privilege, once the thing acting on your behalf makes its own decisions. - [Why agent memory is not just a vector database](https://satunix.github.io/site/blog/agent-memory-is-not-a-vector-database.md) (2026-09-23, draft): Task state, provenance, authority and time all matter. Similarity search alone captures none of them. - [Agents need a control plane, not just a system prompt](https://satunix.github.io/site/blog/agents-need-a-control-plane.md) (2026-09-23, draft): A system prompt is a request, not a boundary. Tool-using agents need enforcement that sits outside the model. - [Pentesting cloud IAM as a graph problem](https://satunix.github.io/site/blog/cloud-iam-as-a-graph-problem.md) (2026-09-23, draft): Roles, trust policies, STS and cross-account access form a graph. Testing it means finding paths, not misconfigurations. - [Designing cyber agents that know their rules of engagement](https://satunix.github.io/site/blog/cyber-agents-and-rules-of-engagement.md) (2026-09-23, draft): Scope should be enforceable machine state, not prose buried in a prompt. - [Dynamic delegation: letting agent topology follow the problem](https://satunix.github.io/site/blog/dynamic-delegation.md) (2026-09-23, draft): Fixed multi-agent org charts may be the wrong abstraction. What if structure formed around each task instead? - [Building an evidence-first AI pentesting agent](https://satunix.github.io/site/blog/evidence-first-pentest-agents.md) (2026-09-23, draft): Findings, tool calls and conclusions should all resolve back to evidence. A design for AI-assisted testing that keeps humans in charge. - [From pentester to adversarial systems engineer](https://satunix.github.io/site/blog/from-pentester-to-adversarial-systems-engineer.md) (2026-09-23, draft): Offensive security increasingly runs through cloud, identity, APIs, CI/CD and autonomous systems. The job is changing shape. - [Local AI as security infrastructure](https://satunix.github.io/site/blog/local-ai-as-security-infrastructure.md) (2026-09-23, draft): Privacy, model control, isolation and reproducibility: why running models yourself matters beyond cost. - [Building offensive infrastructure as infrastructure](https://satunix.github.io/site/blog/offensive-infrastructure-as-infrastructure.md) (2026-09-23, draft): C2, telemetry, test environments and deployment pipelines deserve the same engineering discipline as production systems. - [Recursive agents and the context problem](https://satunix.github.io/site/blog/recursive-agents-and-the-context-problem.md) (2026-09-23, draft): How does a subagent know what it needs without inheriting the entire parent context? - [Running 27B models on constrained hardware](https://satunix.github.io/site/blog/running-27b-models-on-constrained-hardware.md) (2026-09-23, draft): Quantisation, the VRAM/RAM split, context size and throughput: lessons from running mid-size models on hardware that is not built for it. - [The approval came after the action](https://satunix.github.io/site/blog/the-approval-came-after-the-action.md) (2026-09-23, draft): An agent changed a file before the approval prompt said it was allowed to. Why UI-level approvals are not enforcement. - [TTFT is often more important than tokens per second](https://satunix.github.io/site/blog/ttft-matters-more-than-tokens-per-second.md) (2026-09-23, draft): For interactive and agent workloads, waiting for the first token shapes the experience more than raw generation speed. - [What adversary emulation is actually for](https://satunix.github.io/site/blog/what-adversary-emulation-is-for.md) (2026-09-23, draft): Not a trophy hunt. Attack-path discovery, telemetry, visibility gaps and proving that detections and playbooks work. --- # Why more agent autonomy creates a security architecture problem Source: https://satunix.github.io/site/blog/agent-autonomy-is-a-security-architecture-problem/ > Authority, delegation, trust boundaries and least privilege, once the thing acting on your behalf makes its own decisions. Published: 2026-09-23 Tags: ai-security, agents, architecture Status: DRAFT, work in progress (outline and notes, not the finished post) Every increase in agent autonomy is also a delegation of authority. Security architecture has decades of practice with delegation between people and services. Agents break some of its assumptions. ## Authority without intent - A service does what it was coded to do. An agent decides. - [TODO: what that changes for access control] ## Delegation chains - User -> agent -> subagent -> tool -> external system. - Where does the original user's authority stop? - [TODO: example chain and where it should be cut] ## Trust boundaries move - Content the agent reads becomes an input to its decisions. - [TODO: mapping boundaries for an agent deployment] ## Least privilege for agents - Scope tools per task, not per agent. - Short-lived credentials. - [TODO: practical patterns] ## Monitoring and governance [TODO: what to log, who reviews it] --- # Why agent memory is not just a vector database Source: https://satunix.github.io/site/blog/agent-memory-is-not-a-vector-database/ > Task state, provenance, authority and time all matter. Similarity search alone captures none of them. Published: 2026-09-23 Tags: agents, research Status: DRAFT, work in progress (outline and notes, not the finished post) "Memory" in agent systems often means embeddings plus similarity search. That finds text that looks relevant. It doesn't know where the text came from, whether it is still true, or whether it should be trusted. ## What memory needs to carry - **Task state**: where the work is up to. - **Provenance**: where each fact came from. - **Authority**: who is allowed to have written it. - **Time**: when it was true. - [TODO: examples of each failing] ## Memory as an attack surface - Poisoned memories persist across tasks. - [TODO: how provenance limits the damage] ## Healing - Detecting and repairing wrong or stale context. - [TODO: approach] ## A sketch of a better design [TODO] --- # Agents need a control plane, not just a system prompt Source: https://satunix.github.io/site/blog/agents-need-a-control-plane/ > A system prompt is a request, not a boundary. Tool-using agents need enforcement that sits outside the model. Published: 2026-09-23 Tags: ai-security, agents Status: DRAFT, work in progress (outline and notes, not the finished post) A system prompt tells an agent what it should do. It does not decide what the agent *can* do. As soon as an agent holds real tools (a shell, a cloud API, a browser, someone's inbox) the gap between those two things is the whole security problem. ## The prompt is not the boundary - Instructions compete with everything else in the context window: retrieved documents, tool output, web pages, other agents. - Anything the model reads can argue with the prompt. Sometimes it wins. - [TODO: short example of an instruction being overridden by context. Keep it generic.] ## What a control plane looks like - Sits between the agent and its tools, outside the model. - Every tool call is a request: explicit allow, explicit deny, or approval required. - Decisions consider the call *and* what the user actually asked for. - [TODO: diagram - agent -> gate -> tools, with the approval path] ## False authority and context poisoning - Text that claims authority ("the admin says it's fine") is still just text. - Where untrusted content enters the context, and why that matters for tool calls. - [TODO: link to the Autonomy Gate project page] ## What to enforce, and where - Deterministic rules first, model-based judgement second. - Approvals that gate execution, not approvals that decorate it (see: the approval came after the action). - [TODO: checklist readers can apply to their own agent deployments] ## Closing [TODO: one paragraph - control belongs in the system, not in the prose.] --- # Pentesting cloud IAM as a graph problem Source: https://satunix.github.io/site/blog/cloud-iam-as-a-graph-problem/ > Roles, trust policies, STS and cross-account access form a graph. Testing it means finding paths, not misconfigurations. Published: 2026-09-23 Tags: cloud, aws, offensive-security Status: DRAFT, work in progress (outline and notes, not the finished post) A list of IAM findings rarely shows the real risk. The risk is in the paths: this role can assume that one, which can read this secret, which unlocks that account. Cloud identity is a graph, and testing it well means walking it. ## Nodes and edges - Nodes: principals, roles, resources, accounts. - Edges: trust policies, permissions, role assumption, resource policies. - [TODO: synthetic diagram] ## Starting from an assumed breach - What the compromised workload can see first: metadata, credentials, its own permissions. - [TODO: enumeration approach, generic] ## Finding paths - Privilege escalation edges. - Cross-account trust. - [TODO: approach and tooling, no client detail] ## Reporting paths, not findings - Show the chain end to end. - Recommend the cut that breaks the most paths. - [TODO: synthetic example of a path write-up] --- # Designing cyber agents that know their rules of engagement Source: https://satunix.github.io/site/blog/cyber-agents-and-rules-of-engagement/ > Scope should be enforceable machine state, not prose buried in a prompt. Published: 2026-09-23 Tags: ai-security, pentesting, agents Status: DRAFT, work in progress (outline and notes, not the finished post) Human testers work inside a signed scope and rules of engagement. An agent doing security work needs the same, and "please only test these hosts" in a prompt is not it. ## Scope as data - Targets, time windows, allowed techniques, as structured state. - Signed, versioned, checked on every action. - [TODO: schema sketch] ## Enforcement points - Before every tool call, outside the model. - [TODO: what happens on a violation] ## Human approval for real-world actions - Which actions always need a person. - [TODO: approval flow] ## Testing the guardrails [TODO: how to prove the agent can't leave scope] --- # Dynamic delegation: letting agent topology follow the problem Source: https://satunix.github.io/site/blog/dynamic-delegation/ > Fixed multi-agent org charts may be the wrong abstraction. What if structure formed around each task instead? Published: 2026-09-23 Tags: agents, research, soar Status: DRAFT, work in progress (outline and notes, not the finished post) Most multi-agent systems start with an org chart: a planner, a coder, a reviewer, a tester. The structure is decided before the problem is known. SOAR starts from the opposite end: give an agent a goal and a plan, and let it decide whether the work fits in one unit or needs to be split. ## The core loop 1. Receive goal + plan. 2. Can this be completed as one unit of work? 3. If yes, do it. If no, decompose, and delegate each part to a worker built for it. 4. Workers apply the same loop, recursively. [TODO: diagram of a task tree forming and collapsing] ## Why fixed hierarchies struggle - Some tasks are one step; some are hundreds. A fixed shape fits neither well. - [TODO: an example task where a fixed pipeline wasted effort or missed a dependency] ## The hard parts - **Context routing**: what does each worker need to know, and nothing more? - **Task-local memory**: state that belongs to a subtask, not the whole run. - **Healing**: what happens when a worker fails or wanders off. - **Verification**: "done" has to be checked, not declared. - [TODO: which of these is solved, which is still open] ## Early observations [TODO: what has worked and what hasn't. No numbers until they're measured properly.] ## Where it goes next [TODO: link to the spec / repo if it goes public] --- # Building an evidence-first AI pentesting agent Source: https://satunix.github.io/site/blog/evidence-first-pentest-agents/ > Findings, tool calls and conclusions should all resolve back to evidence. A design for AI-assisted testing that keeps humans in charge. Published: 2026-09-23 Tags: ai-security, pentesting, research Status: DRAFT, work in progress (outline and notes, not the finished post) An AI pentesting agent that produces confident findings without evidence is worse than no agent at all: it creates work, not results. The design here starts from one rule: every claim must point back to something that was actually observed. ## Principles - Local-first. - Scope and rules of engagement enforced deterministically, not by instruction. - Every tool runs through a governed adapter with typed approvals. - Evidence is append-only. - A human authorises testing actions. ## Architecture [TODO: diagram - planner, adapters, evidence store, report builder, approval path] ## Threats to the agent itself - Prompt injection from target content. - Tool poisoning: output crafted to steer the next action. - Data leakage out of the engagement. - [TODO: how each is contained] ## False positives - An unverified finding is a lead, not a result. - [TODO: the verification step and what counts as evidence] ## Reporting - Every finding links to evidence entries; every evidence entry links to the call that produced it. - [TODO: example (synthetic) finding record] ## Not a replacement for testers [TODO: where the agent helps, where judgement stays human] --- # From pentester to adversarial systems engineer Source: https://satunix.github.io/site/blog/from-pentester-to-adversarial-systems-engineer/ > Offensive security increasingly runs through cloud, identity, APIs, CI/CD and autonomous systems. The job is changing shape. Published: 2026-09-23 Tags: career, offensive-security Status: DRAFT, work in progress (outline and notes, not the finished post) The path in: IT audit, then technology risk, then offensive security. [TODO: one or two sentences on what each stage taught, in your own words.] ## The perimeter moved - Identity is the perimeter; cloud is the network. - APIs and pipelines are attack surface. - [TODO: how testing work has shifted] ## Building is part of the job - Infrastructure, tooling and telemetry around the testing. - [TODO: why engineering skills changed the quality of the work] ## Agents change it again - Testing AI systems; using AI in testing. - [TODO: what that means for the next few years] ## What I'd tell someone starting out [TODO] --- # Local AI as security infrastructure Source: https://satunix.github.io/site/blog/local-ai-as-security-infrastructure/ > Privacy, model control, isolation and reproducibility: why running models yourself matters beyond cost. Published: 2026-09-23 Tags: local-ai, security Status: DRAFT, work in progress (outline and notes, not the finished post) The usual argument for local models is cost. For security work the stronger arguments are control and containment. ## Privacy and data handling - Sensitive material never leaves the environment. - [TODO: which kinds of work this enables] ## Model control and reproducibility - Pinned models and settings; results you can reproduce. - [TODO: why reproducibility matters for evidence] ## Isolation - Agents with local models can run in closed networks. - [TODO: lab setup at a high level] ## The trade-offs - Capability, hardware, maintenance. - [TODO: honest assessment] --- # Building offensive infrastructure as infrastructure Source: https://satunix.github.io/site/blog/offensive-infrastructure-as-infrastructure/ > C2, telemetry, test environments and deployment pipelines deserve the same engineering discipline as production systems. Published: 2026-09-23 Tags: offensive-security, engineering, infrastructure Status: DRAFT, work in progress (outline and notes, not the finished post) Offensive tooling is often built fast and thrown away. That works until you need to rebuild it under time pressure, prove what it did, or hand it to someone else. Treating it as real infrastructure fixes most of that. ## Repeatable by default - Infrastructure as code for everything that gets deployed. - GitOps: the repo is the source of truth. - [TODO: what this changed in practice] ## Telemetry you can trust - Log what the infrastructure does, not just what the target does. - [TODO: telemetry pipeline sketch] ## Operational hygiene - Teardown is part of the deployment. - Secrets, access and cost controls. - [TODO: checklist] ## A worked example [TODO: the phishing simulation platform as a generic case study - front end, telemetry API, cloud infra, CI/CD, dashboards. No client campaigns.] --- # Recursive agents and the context problem Source: https://satunix.github.io/site/blog/recursive-agents-and-the-context-problem/ > How does a subagent know what it needs without inheriting the entire parent context? Published: 2026-09-23 Tags: agents, research, soar Status: DRAFT, work in progress (outline and notes, not the finished post) When an agent delegates, the easy option is to pass everything down. It doesn't scale: each level inherits more noise, costs more, and gets easier to steer with irrelevant content. ## Too little vs too much - Too little: the worker guesses. - Too much: the worker drowns, and untrusted content spreads. - [TODO: example] ## Context routing - Decide what each subtask needs at delegation time. - Let workers ask for more, explicitly. - [TODO: the mechanism used in SOAR] ## Returning results - Summaries up, evidence stored alongside. - [TODO: how parents verify child results] ## Open questions [TODO] --- # Running 27B models on constrained hardware Source: https://satunix.github.io/site/blog/running-27b-models-on-constrained-hardware/ > Quantisation, the VRAM/RAM split, context size and throughput: lessons from running mid-size models on hardware that is not built for it. Published: 2026-09-23 Tags: local-ai, infrastructure Status: DRAFT, work in progress (outline and notes, not the finished post) A 27B-parameter model is big enough to be genuinely useful for agent work and small enough to tempt you into running it on hardware that was never meant for it. This is what that looks like in practice. ## Test setup - Hardware: [TODO: CPU, GPU, VRAM, system RAM] - Runtime: [TODO: llama.cpp / llama-server version, flags] - Model and quantisations tested: [TODO] ## Quantisation - [TODO: quality vs size across the quantisations tried] - [TODO: where quality visibly dropped for agent tasks] ## Splitting across VRAM and RAM - [TODO: layers offloaded vs speed] - [TODO: the point where CPU offload stops being worth it] ## Context size - [TODO: memory cost of longer contexts; KV cache settings] ## Throughput and time to first token | Config | TTFT | Tokens/s | Notes | | --- | --- | --- | --- | | [TODO] | [TODO] | [TODO] | [TODO] | ## What I'd do again [TODO] --- # The approval came after the action Source: https://satunix.github.io/site/blog/the-approval-came-after-the-action/ > An agent changed a file before the approval prompt said it was allowed to. Why UI-level approvals are not enforcement. Published: 2026-09-23 Tags: ai-security, agents Status: DRAFT, work in progress (outline and notes, not the finished post) While testing an approval gate for a tool-using agent, the order of events came out wrong: the file had already changed by the time the approval prompt appeared. The user was being asked to authorise something that had already happened. ## What happened - [TODO: sequence of events, generic and reproducible. Agent, tool, file, prompt.] - [TODO: how it was noticed] ## Why it happens - The approval lived in the interface, not in the execution path. - A prompt that *describes* a decision is not the same as a gate that *enforces* one. - [TODO: the specific class of design mistake, without naming a product] ## Approval as enforcement - The tool call must block until a decision exists. - The decision must be bound to the exact call that was approved (arguments and all). - Log the decision and the execution as one record. - [TODO: minimal pattern / pseudocode] ## How to test for it - Race the UI: does anything change before the user answers? - Deny, then check nothing happened. - [TODO: short test checklist] ## Takeaway [TODO: one paragraph. If approval can arrive after the action, it isn't approval.] --- # TTFT is often more important than tokens per second Source: https://satunix.github.io/site/blog/ttft-matters-more-than-tokens-per-second/ > For interactive and agent workloads, waiting for the first token shapes the experience more than raw generation speed. Published: 2026-09-23 Tags: local-ai, infrastructure, agents Status: DRAFT, work in progress (outline and notes, not the finished post) Inference benchmarks love tokens per second. For interactive use, and especially for agents that make many short calls, the number that dominates is how long you wait before anything comes back at all. ## Why TTFT dominates agent loops - Agents make many small calls; each pays the time-to-first-token cost. - Prompt processing grows with context; generation often doesn't need to be long. - [TODO: sketch of where time goes in one agent step] ## What moves TTFT - Prompt length and prefix caching. - Batch and concurrency settings. - Hardware and offload. - [TODO: which of these mattered most in practice] ## Measuring it properly - [TODO: method - warm vs cold, cached vs uncached prefixes] ## Results [TODO: table from real runs. No placeholder figures in the published version.] ## Takeaways [TODO] --- # What adversary emulation is actually for Source: https://satunix.github.io/site/blog/what-adversary-emulation-is-for/ > Not a trophy hunt. Attack-path discovery, telemetry, visibility gaps and proving that detections and playbooks work. Published: 2026-09-23 Tags: offensive-security, adversary-simulation Status: DRAFT, work in progress (outline and notes, not the finished post) Adversary emulation is easy to misread as "red team gets domain admin, writes report". The access is the least interesting output. The value is in what the exercise reveals about how an environment behaves under a realistic attacker. ## What it produces - **Attack paths**: how compromise actually chains together, not a list of isolated issues. - **Telemetry**: real attacker activity for defenders to look at. - **Visibility gaps**: what happened that nobody could see. - **Detection and playbook validation**: do the alerts fire, and does the response work? - **Architectural weakness**: problems no single finding captures. ## Designing an emulation that answers questions - [TODO: start from the question, not the technique list] - [TODO: how scope and safety constraints shape the plan] ## Working with the blue team [TODO: before, during, after - generic, not tied to any engagement] ## Reporting what matters [TODO: paths and gaps over trophies]