seif@tourky:~$ available
about stack work contact
available for work msc artificial intelligence uk · italian citizen

generative ai engineer · agentic systems · full-stack

Seif Eldin
Tourky.

I build agentic LLM systems end to end: agent loops, multi-agent coordination, evaluation harnesses, guardrails.

What interests me is what happens after the demo: evaluation, failure handling, and constraints the model can't negotiate with.

see work get in touch
constraint_layer.pypython
1# the guarantee lives here, not in the prompt
2
3class ConstraintLayer:
4    def enforce(self, proposal, state):
5        for hold in self.safety_holds:
6            if not hold.satisfied(proposal, state):
7                return self.fallback(hold)
8        return proposal
9
10# any backend. same guarantee.
11agent = Agent(
12    backend=LLMBackend("claude"),
13    tools=[CriticalPathProjector()],
14    constraints=ConstraintLayer(SAFETY_HOLDS),
15)
16
17# swap it and the guarantee has to survive
18agent.backend = RuleBackend()
19benchmark(agent, scenarios, baseline=True)
holds: 86/86 verified

01 // what i do

Engineering at the seam between agents and production.

Three things I'm reliably good at.

service · 01

Agentic AI systems

Agent loops, tool calling, multi-agent coordination, prompt engineering, evaluation harnesses. Reliability over demo quality.

pythonanthropicopenaievals

service · 02

Guardrails & evaluation

Constraint layers in code, audit logging, benchmarking against baselines, failure-mode analysis. Behaviour you can prove.

pytestaudit logsbaselines

service · 03

Full-stack delivery

Node and TypeScript services, Nuxt / Vue and React front-ends, REST APIs, relational data. Shipping and supporting it after.

nodetypescriptnuxtmysql

02 // about

A guarantee in a prompt is only a request.

Software engineer, MSc in Artificial Intelligence. Recent work is agentic: agent runtimes, tool use, evaluation harnesses, and the plumbing that makes them safe to ship.

A model can quietly decline an instruction on input nobody anticipated. So the constraints that matter sit below the reasoning layer, in code, where the model has no say. Swap the backend: if the guarantee survives, it was real.

Same reason I benchmark against baselines and publish flat results. A method that wins everywhere is evidence of tuning, not contribution.

Underneath it, ordinary production engineering: full-stack delivery, REST integration, testing, CI/CD, and client work I still support after handover.

msc airoehampton · 2026
since 2019building software
4 systemspublic on github
en · it · arworking languages

03 // stack

Tools I reach for first.

Built with, not read about.

ai & agents01
python3.12
anthropicsdk
openaisdk
agent loops*
eval harness*
backend02
node20
typescript5
java*
mysql8
rest apis*
frontend03
nuxt3
vue3
react18
typescript5
practice04
git*
ci/cd*
pytest*
code review*
agile*

// python where the ai work lives. node and typescript across the rest.

04 // work

Selected work, all public.

The code is the claim.

case · 012026

Agentic turnaround delay recovery

turnaround_copilot.py

Problem

On a turnaround, a delay's cause is knowable before the clock can prove it. Nothing was using that window.

Approach

An agent loop exposing a critical-path projector as a callable tool, so the LLM orchestrates a deterministic solver rather than estimating. Safety holds enforced by a constraint layer. Swappable backend for baseline comparison.

Outcome

Warning lead improved over a 40-day evaluation, attribution correct on every case. One delay code tied, and I reported it.

19.8 → 23.8min warning lead
85 / 86earlier than baseline
86 / 86correct attribution
pythonagent looptool useevalsguardrails

github.com/21seift/turnaround-copilot
case · 022026

Multi-agent security assessment

coordinator.py · base_agent.py · audit.py

Problem

Agents acting autonomously in an adversarial environment. Nobody trusts that without a record of what happened.

Approach

I wrote the reasoning layer: a base-agent abstraction and a coordinator running four specialist agents for reconnaissance, analysis, validation and reporting, through a staged pipeline with structured handoffs.

Outcome

An append-only audit logger giving tamper-evident traceability of every decision, plus integration tests covering handoff paths and failure modes.

pythonmulti-agentcoordinatoraudit loggingintegration tests

github.com/rostam-sodagari/AutoPentest
case · 032026

Hybrid reward modelling

reward.py · ablation.ipynb

Problem

Outcome-only rewards ignore how a model got there. Would rewarding intermediate steps give a richer signal?

Approach

A hybrid outcome-plus-process reward model for TinyLlama on GSM8K, ablated against outcome-only. Small scale.

Outcome

Null result, published as it came. The useful part: I couldn't tell whether the process signal carries nothing, or my reward function was badly specified. I now ask what a negative result would tell me before building the evaluation.

pythongrporeward modellingablation

github.com/21seift/grpo-hybrid-reward

// all public. happy to walk through any of it.