Articles
All articles.
How the work gets done now
A plain-language tour of how AI agents actually work together, from one worker to a managed team, and why the human job shifts from doing to directing. No engineering background required.
PatternA2A Protocol in 200 Lines of Lambda
How to implement the Agent-to-Agent (A2A) protocol on AWS Lambda without any SDK. Agent Cards, discovery endpoints, typed TaskRequest/TaskResponse, and live delegation between ops agents.
PatternHow agents remember and talk to each other
How the roo-context MCP server provides persistent memory across agent sessions, and how two AI agents coordinate on the same codebase without a human relay.
PatternAgent Observability Without the Platform
How to instrument AI agents for observability using DynamoDB and plain HTML, without Langfuse, Honeycomb, or any dedicated platform. Token counts, latency, cost estimation, and decision traces.
Pattern21 agentic patterns, mapped to a real platform
21 agentic design patterns from Gulli's taxonomy, mapped to a real platform. Where each pattern lives in ticketyboo.dev's architecture, with specific files and workflows.
FindingThe AI cost iceberg
API tokens are the visible tip. The real cost of AI is in engineering time, rework, integration, monitoring, compliance, and opportunity cost. A framework for presenting AI spend to a CFO.
PatternBuildABeast: the home lab that became a pattern library
A home lab running on four servers and two NAS boxes. Hive architecture, 4-tier LLM routing, autonomous monitoring minions — this is where those patterns were tested first.
FindingContext rot on consumer hardware
Context rot: why long-running agent sessions degrade faster on constrained hardware than token limits alone predict. Attention dilution benchmarks across 4k, 32k, and 128k context sizes.
FindingData governance patterns
GDPR-compliant data handling patterns in serverless architectures — data governance on ticketyboo.dev
PatternGatekeep as Governance-as-a-Service
How Gatekeep maps to the Governance-as-a-Service pattern from Gulli's agentic design patterns book. Declarative rules, persona dispatch, and an audit trail that survived a platform migration.
PatternLoopForge: auditable state machines for the dev lifecycle
LoopForge: a typed, auditable state machine for the dev lifecycle — because AI-generated pipelines need audit trails, not ad-hoc if/else logic
PatternThe MCP token tax on a homelab budget
Every MCP tool call carries token overhead: server description, tool schemas, invocation format. On a homelab or Free Tier budget, that overhead is measurable. Here's what it costs and when it's worth it.
PatternMulti-model reasoning
Why different AI models handle different tasks better, and how to orchestrate them for reliable results: multi-model reasoning on ticketyboo.dev
PatternOMNI: building a self-aware capability mesh
OMNI: a self-aware capability mesh that discovers and composes AI tools — architecture and patterns from ticketyboo.dev
PatternPaperclip: the company that runs itself
If OpenClaw is an employee, Paperclip is the company. Open-source agent orchestration with org charts, heartbeats, and per-agent monthly budgets.
PatternPlanning and parallelization in agentic systems
How spec generation implements the planning pattern, and how DAG-based task execution implements parallelization. The fixer-bot as a case study in both.
PatternPlatform architecture patterns
Four platform architecture patterns that keep recurring: monolith-first, strangler fig, cell-based, and mesh/composable. When each works, when each fails, and the real trade-offs from systems that have been through all of them.
PatternPolicy as code for AI agents
Every governance approach for AI agents is converging on the same architecture: rules as executable code evaluated at runtime. OPA, MCP gateways, and JSON persona rules compared.
PatternReflection and adaptation in agentic systems
How code review loops, session retrospectives, and iterative refinement implement the reflection and learning patterns from the Gulli agentic taxonomy.
PatternRouting work and guarding the gates
How Gatekeep routes work to the right agent persona and enforces governance without blocking. Agentic patterns 2 (Routing) and 18 (Guardrails) from the Gulli taxonomy.
PatternRouting work to the right model
Not all work costs the same. The agentic fixer-bot classifies every issue before picking a model, a runtime, and an execution strategy.
FindingYou can't saturate your way into chaos
Parallel AI agents hit negative returns faster than you expect. The Universal Scalability Law explains why, and the data from multi-agent benchmarks confirms it.
PatternTeaching a scanner to learn from its mistakes
How a feedback loop, a nightly aggregator, and a lessons-learned document injected as RAG context make a static scanner progressively more accurate.
PatternThe self-improving loop
OMNI finds a gap. Engine files an issue. AutoDev builds it. Governance passes it. It merges. OMNI registers it. The mesh grew itself.
PatternServerless agent architecture
Why serverless is a better fit for agentic workloads than persistent servers. Four-tier hierarchy, isolation by construction, and what the Free Tier constraint reveals about architectural clarity.
FindingTechnology due diligence in 90 minutes
Technology due diligence in 90 minutes: the CTO playbook for assessing a target's tech estate during M&A. Infrastructure, security, engineering, data, team, and vendor risk.
LeadershipThe first 90 days as a fractional CTO
What the work actually looks like. Three phases, one assessment scale, three meetings before day twenty. Drawn from a sequence of engagements where the board had lost confidence and ninety days was the runway.
PatternScanner Pro: evidence-grade tool verification
Free scan finds patterns. Pro scan runs bandit, semgrep, checkov, detect-secrets, pip-audit, and ruff. Why method_label: "tool_verified" matters for governance audit trails.
Build LogBuild log: shipping a governed AI coding assistant in one month
Lambda, Cognito, Stripe, DynamoDB, a VS Code extension, 473 tests. No EC2. Every decision, every gotcha.
PatternRepo as data structure
Google, Meta, Microsoft, Amazon, and Apple all solved the monorepo problem differently. AI assistants change which trade-offs matter.
FindingThe automatable middle
Coding is 25–35% of the lifecycle. AI automates that slice. The bottleneck moved upstream: to intent quality, not implementation speed.
FindingTokens in the desert
$1.15 trillion in AI infrastructure over three years. The business model is tokens on a metre. Whether your use case works is your problem.
FindingSpend like you mean it
Subscribe, burst, own. For every dollar on API tokens expect $2–7 more in hidden costs. A framework for knowing which bucket your AI spend sits in.
PatternGovernance that runs as code
Policy documents become enforceable checks inside the development loop. The difference between a rule that exists and a rule that runs.
PatternWhen agents plan their own work
AI agents that plan, execute, and verify. Where this works, where it breaks, and what the failure mode looks like when it goes wrong quietly.
PatternThe boring replacement is better
A 5-link dependency chain failed. Four Lambda functions and a DynamoDB table replaced it. Fewer moving parts, fewer failure modes.
PatternOne config file, one tenant stack
A separate Lambda, DynamoDB, and CloudFront stack per tenant from a single config file. The B2B2C pattern that does not require retrofitting.
PatternScripts at scale
60+ Python scripts across M365, AWS, SharePoint, SQL, Jira, Freshservice, Salesforce. What enterprise operational tooling looks like when it stops being one-off.
PatternAgentic code review
Five governance personas, one pull request. What it looks like when security, finance, privacy, compliance, and data all review the same code change.
PatternThe deliberation engine
Four AI personas deliberate on a problem before any code is written. The architecture behind structured AI disagreement.
PatternBuilding on a budget with humans in the loop
How garden leave, AWS free tier, and a 4-tier human-in-the-loop framework shaped three months of building.
PatternAgentic development contracts
Machine-readable, machine-enforceable bilateral contracts for AI agents. The same rigour as hiring a dev house, applied to your codegen.
PatternThe governance proxy
An MCP-compatible proxy that intercepts agent actions, evaluates them against policy, and blocks or permits in real time.
PatternShift left: security scanning at every stage
Shift-left security in practice: pre-commit to org-level scanning without an enterprise budget.
Case StudyB2B2C sector study: grants distribution platform
A full-stack B2B2C platform serving grants distribution at scale. Salesforce, Lambda, multi-tenant DynamoDB. One config file per tenant.
PatternAuditing a Salesforce org for divestiture
Five stages. Read-only. SOQL and the Tooling API. Numbered findings with evidence. A remediation register before the steering group asks for one.
PatternThe agentic stack: seven layers from zero to self-healing
Seven stackable layers that take you from an empty AWS account to a self-healing, governed agentic platform. Each layer is independently deployable.
FindingI can audit all your systems — latest to legacy
The RST scale was built to score GitHub repositories. It was never only about code. Any system with observable outputs can be scored and remediated.
PatternFire and forget: async task queues for AI coding sessions
A pattern for offloading slow AI tasks from an interactive coding session to a background worker queue, with results read back on completion.
PatternClosing the loop: from issue to pull request
Automating the journey from a discovered issue to a merged pull request — the AutoDev pipeline pattern for governed agentic delivery.
PatternBrood: worker queues for governance agents
Persona-based worker queues that give governance agents a concrete job to do — patterns for decoupled, observable agent work.
PatternSeeing the data you didn't know you had
How to build a data governance layer over a messy enterprise Microsoft 365 tenant — SharePoint crawl, classification, and visibility dashboard.
PatternPersonas before governance
From Springfield character names to Smithers the LLM observer to a full AI committee review system: the evolution of persona-based governance.
Build Log43 Repos in 70 Days
A data-backed view of how an AI-native platform converged from exploration to production in 70 days. Commit velocity, issue closure rate, cost per feature.
PatternThe contract model for AI development
A DevContract is a machine-readable Statement of Work for AI developers. Three phases, eight clause types, one enforceable governance loop.
DemoAI agents, attack vectors, and a contract that prevents both
CVE-2026-21852 live in the scanner. DevContract governing the agent run. Signed evidence receipt at the end. Two interactive demos — all client-side.
ticketyboo makes AI-assisted software delivery legible, enforceable, and provable. Start free — no credit card, no install required.