Taamir Khan is a software engineer who builds banking software, and is working on making AI agents safer and cheaper to run.
He cares about understanding people and explaining things clearly.
now: Software Engineer II, Argo Data
building: guardrail-proxy · incident-responder
01 — About
I build teller software for banks: the screens and services behind a deposit or a withdrawal.
I am a software engineer II at Argo Data. Before that I was an Android developer at Synchrony, on the CareCredit app, and a software development engineer intern at Amazon, on Fire TV.
I have a B.S. in Computer Science from the University of Connecticut. My GPA is 3.70.
Résumé. GPA 3.70.
I care about understanding people and explaining a system clearly. That is also why I am moving toward AI governance, and toward agents that do not waste tokens.
02 — Experience
Dates, titles, and figures in this section are from the résumé.
Software Engineer II
- I design and ship full-stack features across a distributed, three-tier teller banking platform: a JavaScript/HTML front end, a proprietary middle-tier configuration layer, and C# integration services wired to the Fiserv Signature core host, for multiple bank clients.
- I re-engineered end-to-end withdrawal transaction logic for six account types (Checking/MMA, Savings, CD, IRA, Consumer LOC, Commercial Loan Draw) across all three tiers, tracing a multi-layer root cause through distributed system logs to clear host-rejection and balance-validation failures.
- I extended middle-tier data-enrichment services and host-integration calls to add real-time account-ownership safeguards (Guardian, Conservatorship, Representative Payee) across teller workflows, reducing teller error on protected accounts.
- I earned an early promotion, within ~12 months of joining, for taking on increased ownership of complex, cross-tier work.
Résumé. Six account types. Early promotion within ~12 months of joining.
Android Developer, CareCredit
- I designed and shipped a telehealth feature in the production CareCredit app, integrating in-app video conferencing and geo-based provider search.
- I built and optimized Android features in Java and Kotlin, in Android Studio, on an Agile team, adding in-call controls such as mute, camera toggle, chat, and screen recording via a third-party API.
Résumé.
Software Development Engineer Intern, Fire TV
- I built a predictive analytics model on Ceviche telemetry to anticipate user navigation on Fire TV, reaching 80–85% accuracy across 35M+ users.
- I implemented Spark (Java) pipelines to preload UI screens and drive content recommendations, using AWS Athena, EMR, and S3.
Résumé: 80–85% accuracy across 35M+ users.
Education
Coursework: Systems Programming, Algorithms & Complexity, Big Data Analytics, Databases, Cloud Computing, Probability & Statistics.
Résumé. GPA 3.70.
03 — Projects
The agent can suggest a transfer.
A rule decides whether it goes through.
Deterministic guardrail and audit proxy
I wrote a Go proxy that sits between an LLM agent and financial APIs. It checks every tool call against a strict schema and a deterministic rule before anything reaches the real API. The code uses the Go 1.22 standard library and no third-party dependencies.
The schema rejects unknown tools and fields, missing or duplicate fields, and wrong types before any rule runs. Money is integer cents parsed straight from the JSON text. Floats are rejected, so $500.00 and $500.01 stay distinct. Transfers over $500 need human approval, and only an allowed call is forwarded. The request body limit is 64 KiB.
The approval webhook signs requests and responses with HMAC-SHA256. Each approval is single-use, tied to the SHA-256 hash of the exact call, and times out to deny after 5 seconds, so a captured approval cannot be replayed against a different amount.
PII redaction covers emails, phones, SSNs, Luhn-checked card numbers, ABA routing numbers, labeled account numbers, and mod-97 IBANs. Each value becomes a stable typed placeholder, and the proxy restores the originals in the model's reply. The mapping is never sent out or logged. On the labeled corpus there were 0 false positives on 25 strings that must survive, 0 false negatives on 12 target PII strings, and 3 known misses: a personal name, a street address, an obfuscated email.
The audit log is append-only and hash-chained, signed with Ed25519. Each entry records a tool call (as a hash, never raw arguments), a rule decision, an approval, a redaction (counts only), or a forward. A signed tip file catches truncation, and a verify command points to the first tampered entry. The log uses in-process and file locks so more than one writer can append, and it can resume after a restart. The suite includes edit, delete, reorder, truncate, and wrong-key tamper cases.
make demo runs every guardrail end to end: an allowed transfer, an approved and a
denied $750 transfer, a rejected float amount, a PII round trip, and an audit verify that catches
a one-byte tamper. The built demo binary ran end to end in 0.027 s and 0.019 s of real time,
not counting compilation. Two runs, not a benchmark. GitHub Actions CI runs tests, vet,
and the race detector.
Project notes. The $750 transfer is a step in the demo, not a second rule. The approval line in the notes is still $500. Demo times: built binary, excludes compile. Two runs, not a benchmark.
Milestones
Shipped Schema and rule engine, config file, HTTP proxy, and a fake upstream API for testing. 210 test cases, 28 test functions. PR #1
Shipped Human-in-the-loop approval webhook with a fake approver for tests. 234 test cases, 36 test functions. PR #2
Shipped PII redaction with restore, plus a fake LLM for tests. 279 test cases, 46 test functions. PR #3
Shipped Signed, hash-chained audit log with a verify command. 294 test cases, 56 test functions. PR #4
Shipped Demo agent, hiring-manager README, and CI. 296 leaf tests, 58 test functions. PR #5
guardrail-metrics.json. Counts are the suite size recorded at that milestone. Every milestone is shipped on its own pull request. median of five 1s go test -bench runs. Go 1.22.2 · linux/amd64 · Intel Xeon · GOMAXPROCS=4.
| check: allow ($500.00) | 6,551 ns/op |
|---|---|
| check: needs_approval ($500.01) | 6,416 ns/op |
go test -bench · Go 1.22.2 · linux/amd64 · Intel Xeon · GOMAXPROCS=4. median of five 1s go test -bench runs. 115 allocations and 5,496 bytes per check. That median works out to about 152,648 checks/sec on one core. This is derived from the median, not a separate load test.
| proxy allow, localhost upstream | 51,058 ns/op |
|---|---|
| PII redaction, 572-byte prompt | 101,189 ns/op |
| proxy approval round trip, localhost webhook | 162,754 ns/op |
| audit append with fsync | 472,600 ns/op |
Approval adds ~111,696 ns (difference of the two proxy medians, not a separate benchmark). The full approval round trip over localhost adds about 112 µs (162,754 vs 51,058 ns/op). That 112 µs is the difference between the two medians, not a separate benchmark. Difference computed from the two proxy medians: 111,696 ns. Redaction: 54 allocs/op on a 572-byte prompt. Append, with fsync of both the log and the tip file: 80 allocs/op.
Signing and checking one approval, with no network, takes a median of 3,689 ns. The full approval round trip over localhost adds about 112 µs (162,754 vs 51,058 ns/op). That 112 µs is the difference between the two medians, not a separate benchmark.
That median works out to about 152,648 checks/sec on one core. This is derived from the median, not a separate load test. For the first milestone, go test, go vet, and the race detector all pass.
Verifying 10,000 entries takes a median of 421.05 ms. The bench record for that verify is 421,053,507 ns. It is left off the chart because it is not on the same scale as the other medians.
Project notes for 421.05 ms, the allocation counts, the body limit, and the checks-per-second line. The nanosecond medians are the JSON values. This is derived from the median, not a separate load test.
check: allow ($500.00),6551,1
check: needs_approval ($500.01),6416,1
audit append with fsync,472600,4
audit verify 10000 entries,421053507,4
Latency table, copied as recorded. The last line is the verify median, stated above and not plotted.
Four services, gateway, orders, inventory, and payments, can be failed on purpose.
A reviewer can check every claim against a real log line.
Multi-agent incident responder
This is a Python simulation of a microservice outage. Gateway, orders, inventory, and payments emit OpenTelemetry traces, logs, and metrics. A fault injector plants four faults as real commits in a sample service history, so git blame can find them. It is the base for a multi-agent root-cause system. Milestones 1 and 2 are built. The later agents are not.
faults live in the service code as git commits, not as flags in the simulator, so the telemetry and git blame point to the same line.
Fixed misattributed latency in nested calls by measuring each service's own span time (child spans subtracted), so a slow dependency isn't blamed on its callers.
Tradeoff: a sequential simulated clock makes runs fast and exact, but it can't show queueing or concurrent requests.
Milestones
Shipped Simulated microservices, fault injector, and ground truth Merged Nov 16, 2026. PR #1
Shipped Log Forensics agent Deterministic detection, citation check, and a scored eval. The optional LLM summary is off by default. PR #2
Planned Code Archaeologist agent Recent commits, git blame.
Planned Runbook agent Mitigation steps.
Planned Citation-checked RCA report
Planned README with demo
Status is per milestone. Code Archaeologist, the runbook agent, the RCA report, and the README with a demo are planned, not shipped.
| latency_spike | 0.0239 s |
|---|---|
| error_rate_spike | 0.0257 s |
| dependency_timeout | 0.0291 s |
| bad_deploy | 0.0231 s |
All numbers come from the project's cloud agent runs on Nov 16, 2026 (seed 1, 24 requests, 8 warmup for fault_runs.csv; seeds 1-5 for the eval).
| Fault | Spans | Logs | Metrics | Traces | Log bytes | Metric bytes | Truth |
|---|---|---|---|---|---|---|---|
| latency_spike | 120 | 120 | 28 | 43,584 | 26,592 | 7,373 | 463 |
| error_rate_spike | 120 | 120 | 28 | 44,544 | 26,784 | 7,360 | 473 |
| dependency_timeout | 120 | 136 | 28 | 45,048 | 30,308 | 7,373 | 458 |
| bad_deploy | 120 | 120 | 28 | 45,344 | 26,976 | 7,361 | 454 |
fault-runs.json. Byte columns are traces, logs, metrics, and the ground-truth file. All numbers come from the project's cloud agent runs on Nov 16, 2026 (seed 1, 24 requests, 8 warmup for fault_runs.csv; seeds 1-5 for the eval).
| Record | Passed | Seconds |
|---|---|---|
| 1_simulator | 12 | 0.68 |
| 2_log_forensics | 49 | 1.30 |
tests-by-milestone.csv. These are the recorded runs, not a sum of the two rows.
The Log Forensics eval ran 20 cases (4 faults, seeds 1, 2, 3, 4, 5). 20 of 20 named the right service. Onset error was 0 ms. Citations resolved: all. Runtime 0.509 s. Tokens in: 0. Tokens out: 0. LLM called: false.
Tokens: 0 in, 0 out (deterministic mode, no LLM called).
Simulator faults start at a clean boundary and stay on; eval is easy by construction. Short blips that recover could be missed.
| Fault | Service | Correct |
|---|---|---|
| bad_deploy | payments | 5 |
| dependency_timeout | payments | 5 |
| error_rate_spike | payments | 5 |
| latency_spike | inventory | 5 |
log-forensics-eval.json. Simulator faults start at a clean boundary and stay on; eval is easy by construction.
{"cases": 20, "faults": 4, "seeds": [1,2,3,4,5], "correct_service": 20, "onset_error_ms_max": 0.0, "citations_resolved": "all", "runtime_seconds": 0.509, "tokens_in": 0, "tokens_out": 0, "llm_called": false,
"per_fault": {"bad_deploy": {"service": "payments", "correct": 5}, "dependency_timeout": {"service": "payments", "correct": 5}, "error_rate_spike": {"service": "payments", "correct": 5}, "latency_spike": {"service": "inventory", "correct": 5}},
"note": "Simulator faults start at a clean boundary and stay on; eval is easy by construction."}
Eval record, copied as stored.
04 — Play
One rule from the proxy, in a form you can move.
Does this transfer go through?
A toy version of the real rule engine.
Enter cents, or type a decimal. 50000 cents is $500.00. One cent more needs approval. A decimal point is rejected.
A toy version of the real rule engine. Transfers over $500 need human approval, and a float string is rejected. The slider ends at 50001 cents, which is $500.01. It is not a measured limit.
05 — Contact
Email is the best way to reach me.