Eason

Life update: finished my 4 years at @UniofOxford. A lot of building, learning, and fun. A lot of memories at @KebleOxford :) Will miss Oxford quite a bit.

@KebleOxford @UniofOxford Thank you!

@learningPikachu @UniofOxford Good luck with your next chapter!

Life update: finished my 4 years at @UniofOxford. A lot of building, learning, and fun. A lot of memories at @KebleOxford :) Will miss Oxford quite a bit.

This paper completely changed how I think about a swarm of agents: Describe an agent as a graph -> Nodes are operations -> Edges are information flow -> Wire agents into one graph -> Optimize the graph itself automatically Here is the 5-step blueprint: Agent as a graph: any LLM agent is represented as a computational graph, where nodes are functions that process data or query the model. Edges as links: edges define the information flow between operations, that is who passes a result to whom inside an agent and between agents. Composition: graphs are recursively assembled into large composite graphs, so a swarm of agents becomes one object instead of a pile of hand-written scripts. Node optimization: the first optimizer automatically tunes prompts at the level of individual nodes. Edge optimization: the second optimizer uses RL to change graph connectivity, that is the orchestration of the swarm itself, cutting useless links and keeping the working ones. Key insight: you do not hand-design a swarm's topology; graph connectivity is a learnable parameter optimized like weights. Two levels of auto-optimization - node prompts and edge connectivity - turn scattered agent frameworks into one optimizable graph. Read this, then check the article below.

@omarsar0 Interesting! A dynamic, evolving agent harness is really cool. What I also think of is if agent harness could also be 'trained' to a certain extent.

Great research paper on optimizing harnesses. (bookmark it) There is a lot of alpha in building a harness. And you don't need much to keep them optimized. This paper argues you can do this effectively using the harness own executions. The harness is the external control layer that turns a base LLM into an executable agent. Automatic improvement methods optimize a narrow part of it, usually prompts or pipelines, and deployed agents then reuse a single global harness for every case. MemoHarness decomposes the harness along the temporal flow of inference into six editable control surfaces (context, tool, generation, orchestration, memory, output) and turns improvement into structured editing over those dimensions. It documents per-case diagnoses plus distilled global patterns about what works and how dimensions interact, then adapts to each new case by retrieving similar past cases. No compute is waisted on test-time labels, feedback, gradient updates, or extra search. On the shell-agent benchmark it reaches 0.806 against 0.722 for the strongest fixed-harness baseline, at lower per-task dollar cost than the strongest commercial baselines compared. Paper: arxiv.org/abs/2607.14159 Learn to build effective AI agents in our academy: academy.dair.ai

@quxiaoyin 500M is really impressive!

Remember Manus? It still has 500M ARR...

Very nice to see Relay using Aicoo Infra in building scalable agent to agent product!

Chatted w/ many people in #ICML on a2a, agentic communication, agentic security!

I have recently started as a Research Advisor at @scale_AI working on agentic AI. 🎉Our Second Workshop on Agents in the Wild: Safety, Security, and Beyond at ICML 2026 @icmlconf is only days away! Join us July 11th in Hall B2, COEX, Seoul! 🇰🇷 AI agent safety and security have rapidly become a central focus for the research community. Researchers and practitioners are mobilizing: ✦ 215 papers accepted ✦ 277 reviewers ✦ Up to 800 participants expected ✦ Incredible engagement on a topic that clearly matters.

If I had 6 months to become an Agentic AI Engineer. I'd do this. Stage 1: Python + Async Foundations asyncio, FastAPI, event-driven architecture, error handling, API integration patterns. Stage 2: LLM Fundamentals for Agents Context management, model routing, token economics, latency tradeoffs, failure modes. Stage 3: Tool Calling + Structured Outputs Pydantic validation, function calling schemas, error recovery, dynamic tool discovery. Stage 4: Memory + State Management Short-term buffers, long-term vector recall, context compression, cross-session sync. Stage 5: Single Agent Workflows ReAct loops, plan-and-execute, self-reflection, iteration limits, graceful degradation. Stage 6: Multi-Agent Orchestration LangGraph/CrewAI, supervisor patterns, message passing, conflict resolution, handoffs. Stage 7: Human-in-the-Loop Systems Uncertainty detection, approval gates, audit trails, resume logic, intervention points. Stage 8: Evaluation + Quality Assurance Automated eval harnesses, LLM-as-a-judge, regression testing, hallucination metrics. Stage 9: Observability + Tracing Distributed tracing (LangSmith/Arize), cost dashboards, latency monitoring, alerting. Stage 10: Security + Guardrails Prompt injection defense, output filtering, PII redaction, sandboxed execution, compliance. Stage 11: Production Deployment vLLM/SGLang, Kubernetes scaling, CI/CD for agents, canary releases, rollback strategies. Stage 12: Open Source + Portfolio Ship autonomous agents publicly, write architecture docs, record demos, contribute to libs. Most people stay stuck watching tutorials. Builders get hired. (Bookmark it)

If you have: Hermes Agent Claude Code & Codex Handoffs Obsidian + QMD Memory System Run Agentic Loops Fleet Tailscale Mesh Cron Jobs + Kanban Board Agentic Workflows Congrats you are the top 1% of the AI god stack

@16vchq Applied but no confirmation? Is that expected?

33.5 hours left

⏳ 48 hours left. Applications for the Summer Founder Fellowship 2026 close on June 15 at 11:59 PM PST. If you've been thinking about applying, don't let the opportunity pass by. Apply now: tiny.cc/16VC_s26 #Founders #Startups

spending a Saturday by myself to think about an interesting research problem, learn genuinely important knowledge around it, and think about the solutions & potential is very rewarding.

Getting challenged itself is not comfortable. But figuring out the solution is.

Wrap-up of London & Oxford Tech Week. Let me know if you are working/investing around agent-to-agent infra!

@MaxForAI 我感觉是看情况，在「分布式权限」的条件下，也没有办法给一个master agent所有的权限做所有的事情，这个时候Agent作为人的代理需要相互沟通很正常。 如果是Prompt Engineering来纯聊天可能是另一回事。

龙虾之父Peter表示： Agents 互相对话是一种 Token 浪费。 他还表示大多数他见过的用例都是很蠢的。 有意思🤔

Yes, exactly. C901/max complexity is a good first proxy. My hunch is HL also needs behavioral regularization: reject patches that only fix 1-2 train cases, require held-out transfer, track rollback cost/interactions, and prefer reusable operators over one-off branches. In this setting, code complexity really is model complexity.

@learningPikachu How about using some regularization rules over the code, for example, flake8 C901 max_complexity<=10?

Phase 2 of my heuristic-learning ImageNet-10 experiment: Inspired by @Trinkle23897's “Learning Beyond Gradients,” I used Claude Code + Codex to iteratively improve a pure symbolic vision system. No neural nets. No backprop. Just visual rules, reranking, verification, logs, and code edits. Current reproducible: - full verify: 84.0% train / 50.5% val - base+rerank: 55.4% train / 51.9% val Archived run reached 100% train, but exact code state is not currently reproducible. Takeaway: - Symbolic HL can fit surprisingly well. - The bottleneck is generalization. - If code is the model, then code complexity is model complexity. Check out: github.com/xisen-w/hl-ima… Blog: github.com/xisen-w/hl-ima…

@Trinkle23897 Full writeup, logs, plots, and reproducibility notes here: github.com/xisen-w/hl-ima… I am treating this as a Phase 2 result: not “symbolic vision beats neural nets,” but a concrete vision-domain case study for Heuristic Learning.

So my current takeaway is: LLM coding agents make symbolic heuristic systems maintainable enough to overfit. That is already a real shift. The next question is how to make that maintainability produce generalization: object-centered features, reusable operators, held-out selection, and better credit assignment over code edits.

@Trinkle23897 The lesson for Heuristic Learning is not “write more rules.” It is: if code is the model, code needs regularization. Support size, rule complexity, held-out transfer, cascade risk, and patch-level credit assignment all start to matter.