AI signal curator. Open-source agents, local AI, and tools worth trying early. Experimenting in public.
- Tweets 817
- Following 81
- Followers 34
- Likes 148
Pinned Tweet
AI is moving too fast to MASTER.
So I focus on what is worth trying early instead.
• Open-source agents
• Local & private AI tools
• Frameworks that unlock new workflows
• Research that actually changes how we build
If you like experimenting before the playbooks exist, you are in the right place.
4
249
A 1M-token context window expands what a model can process.
It does not remove the architecture decisions around context.
In production, teams still need to decide:
• what information should enter the context
• what should be retrieved only when needed
• when stored context has become invalid
• which requests need the largest model
• whether the added latency and cost improve the result
Long context reduces some retrieval and continuity problems, but it can also increase data movement, memory pressure, latency and irrelevant information.
The useful question is not how much context a model supports.
It is how much context the workload actually needs, and how the system governs it.
1
10
Reusable agent workflows are becoming the new prompt library.
But the real shift is not "better prompts".
It is packaging execution context:
* task rules
* examples
* repo knowledge
* memory
* handoff state
* scripts
* validation steps
The model generates behavior.
The harness makes behavior repeatable.
2
33
Long-horizon agents do not fail only because the first answer is weak.
They fail because they cannot persist.
Research agents, coding agents, and optimization agents need more than reasoning:
• task state
• evidence trails
• debug loops
• retry policies
• freshness checks
• tool feedback
• stopping criteria
• artifact history
That is why persistence is becoming a serious agent capability.
The useful agent is not the one that produces the best first draft.
It is the one that can keep working, verify progress, recover from failed steps, and leave behind inspectable artifacts.
19
AI agents are moving beyond chat output.
The useful shift is agents producing inspectable artifacts:
• plan files
• research notes
• reports
• spreadsheets
• slides
• code changes
• execution logs
This matters because production workflows need evidence, not just answers.
A chat response is hard to audit.
A file artifact can be reviewed, versioned, tested, shared, edited, and traced back to the workflow that produced it.
The next useful agent layer may not look like a better chatbot.
It may look like a local worker that creates real project artifacts with a visible execution trail.
1
1
27
AI agent tooling is moving down the stack.
The useful work is not only better chat interfaces.
It is:
• faster document parsing
• isolated benchmark environments
• failure-driven skill creation
• guarded shell execution
• worktree-based session isolation
• observable workflow plans
That matters because agents do not fail only at reasoning.
They fail when context is slow, files are messy, tools are unsafe, benchmarks are weak, or recovery paths are missing.
The next agent advantage may come less from "more autonomy" and more from better runtime infrastructure.
24
AI coding agents are quietly becoming cost engineered systems.
Not just:
• better prompts
• bigger context
• stronger models
The useful shift is lower-level:
• prefix caching for long sessions
• tool calls with traceable state
• repo-aware execution loops
• cheaper model routing
• evals around task success, not vibes
As model costs compress, the bottleneck moves.
The winning agents will not only be smarter.
They will be cheaper to run, easier to inspect, and harder to drift.
2
20
Agent harnesses are becoming the control plane for AI systems.
Not the model.
Not the prompt.
Not the tool list.
The harness decides:
• what context enters
• which tools are allowed
• how state is updated
• what gets verified
• when execution stops
• how failures recover
• what gets logged
This is why agent engineering is starting to look more like systems engineering.
The model generates behavior.
The harness makes behaviour governable.
14
Open source agents are making AI engineering cheaper to start.
Local models, coding agents, routers, workflow engines, and self-hosted tools reduce the access barrier.
But they do not remove the hard parts:
• routing policy
• execution safety
• memory control
• observability
• rollback
• eval coverage
• cost boundaries
The mistake is thinking "free to run" means "ready for production".
The real skill is knowing which constraints moved from the vendor layer into your own architecture.
10
Local AI is becoming easier.
That changes the bottleneck.
Running models offline is no longer the impressive part. The harder layer is what surrounds the model:
• task-specific skills
• verification gates
• memory boundaries
• tool permissions
• repeatable execution
The next serious open-source AI projects will not just make models easier to run.
They will make agent behavior easier to control.
10
Agent-native tooling is becoming real infrastructure now.
Control rooms, agent-first languages, local runtimes, and multi-agent repos are all pointing in the same direction.
But the hard part is not launching more agents.
It is defining:
• what each agent can access
• how state changes are reviewed
• how bad tool actions are rolled back
• how failures become evals
The next agent layer is not more autonomy.
It is runtime control.
20
Agent skills are starting to look like packages.
Not prompts you rewrite for every tool.
Reusable units that carry:
• task scope
• operating steps
• environment assumptions
• tool requirements
• safety boundaries
• tests or validation checks
That matters because agent behavior needs to move across Claude Code, Cursor, Codex, local agents, and team workflows.
The hard part is not writing more skills.
It is making skills portable, testable, and safe.
1
14
Agent debugging is becoming its own infrastructure layer.
Once an agent can plan, use tools, edit files, run tests, and call APIs, normal logs are not enough.
You need to see:
• what goal it inferred
• which context it used
• which tools it called
• where the trajectory changed
• what it verified
• what it skipped
Reliable agents need traceable execution, not just better prompts.
7
Agent memory is not just about storing more history.
A useful direction is compact runtime state.
Instead of pushing everything into the context window, memory systems can preserve only the information needed to influence future reasoning.
That changes the design problem:
• what gets retained
• what gets compressed
• what gets ignored
• what gets invalidated
• how memory affects the next step
Better memory is not bigger memory.
It is controlled memory.
9
Coding agents waste a lot of work rediscovering the codebase.
A useful pattern is emerging:
index the repo first,
then let the agent query structured context.
That changes the workflow from repeated file scanning to targeted retrieval.
The benefit is not just fewer tool calls.
It is better context control:
• fewer irrelevant reads
• lower token waste
• clearer entry points
• more stable edits
• better auditability
Agent speed improves when context access becomes infrastructure.
17
Persistent memory for coding agents is useful.
But the hard part is not saving everything.
The hard part is deciding what survives.
Good agent memory needs:
• raw examples for evidence
• compressed summaries for speed
• retrieval boundaries for relevance
• invalidation when facts change
• recovery when memory is wrong
Memory is not storage.
It is a policy layer.
10
Open source AI agents are becoming easier to run locally.
That is useful.
But runs locally is not the same as runs reliably.
The hard parts are still:
• memory boundaries
• tool permissions
• context freshness
• recovery after wrong actions
• evals for multi-step tasks
Local control solves one constraint.
It does not remove the system design problem.
1
21
The next useful layer for AI agents may not be another model wrapper.
It is controlled context delivery.
Most agent failures do not come from missing intelligence.
They come from the wrong file, stale docs, weak permissions, or unclear workspace state.
The useful pattern:
• docs become structured context
• access is permissioned
• agents receive the right workspace state at runtime
This is why self-hosted AI knowledge hubs and MCP-style context systems are worth watching.
Agent reliability starts before the prompt.
14
Most agent systems still treat context like a static snapshot.
But newer systems are starting to treat context as continuously changing state:
delta recompute
live fetch
rolling memory
runtime diagnostics
long-horizon orchestration
The hard problem becomes knowing when previous reasoning is no longer valid.
10