正在加载视频...

视频加载失败

加载此视频时出现问题。这可能是由于临时网络问题，或视频可能不可用。

Before adding another subagent ask what problem it's solving. A bloated system prompt is often the issue. Skills and tool search can fix that without splitting context across agents. My rule of thumb is to keep a subagent when the work is parallel, needs fresh context or one agent... show more

Addy Osmani

473,235 subscribers

77,431 次观看 • 2 天前 •via X (Twitter)

Anya Rossi• Live Now

Private livecam show

0 条评论

暂无评论

原始帖子的评论将显示在这里

相关视频

AGENT ARCHITECTURE ROUTES WORK. IT DOES NOT REMEMBER WORK. THAT GAP IS WHY YOUR LOOP KEEPS FIXING THE SAME BUG TWICE. these are two different engineering problems. every agent that silently drifts is missing one of them. architecture answers what runs. harness → loop → graph. it defines the tools, the retries, the branching routes, the approval gates. context ops answer what the run knows. write → read → compress → isolate. it defines what gets saved between attempts, pulled in on read, summarized on overflow, and split across sub-agents. for two months i believed a solid harness plus a verifier loop was enough. my coding agent kept re-discovering the same test failure across retries. the loop was working. it just had nowhere to write what it had already learned. here is the decision rule: if your agent forgets across restarts, add write and read. if it stalls on long tasks, add compress. if two sub-agents step on each other, add isolate. architecture without context ops is a well-routed system with amnesia.

AGENT ARCHITECTURE ROUTES WORK. IT DOES NOT REMEMBER WORK. THAT GAP IS WHY YOUR LOOP KEEPS FIXING THE SAME BUG TWICE. these are two different engineering problems. every agent that silently drifts is missing one of them. architecture answers what runs. harness → loop → graph. it defines the tools, the retries, the branching routes, the approval gates. context ops answer what the run knows. write → read → compress → isolate. it defines what gets saved between attempts, pulled in on read, summarized on overflow, and split across sub-agents. for two months i believed a solid harness plus a verifier loop was enough. my coding agent kept re-discovering the same test failure across retries. the loop was working. it just had nowhere to write what it had already learned. here is the decision rule: if your agent forgets across restarts, add write and read. if it stalls on long tasks, add compress. if two sub-agents step on each other, add isolate. architecture without context ops is a well-routed system with amnesia.

kocer

12,814 次观看 • 2 个月前

THIS 38,000-STAR GITHUB REPO TURNS ONE AI AGENT INTO A REAL TEAM THAT CAN BRANCH, VERIFY ITS WORK AND WAIT FOR YOUR APPROVAL most people still run agents as one long chain where every step waits, one failure kills the run and the full workflow starts again Task → Planner → 5 Researchers in Parallel → Skeptic → Writer → Human Gate LangGraph gives every node one job while a shared state carries the findings, decisions and context through the entire system the skeptic can reject an unsupported finding and route the work back before it contaminates the final report, while independent branches keep moving if the run crashes, durable execution resumes from the saved state instead of rebuilding everything, then human-in-the-loop pauses the graph before anything expensive gets sent or published bookmark this repo and watch one prompt turn into an actual org chart for AI agents

THIS 38,000-STAR GITHUB REPO TURNS ONE AI AGENT INTO A REAL TEAM THAT CAN BRANCH, VERIFY ITS WORK AND WAIT FOR YOUR APPROVAL most people still run agents as one long chain where every step waits, one failure kills the run and the full workflow starts again Task → Planner → 5 Researchers in Parallel → Skeptic → Writer → Human Gate LangGraph gives every node one job while a shared state carries the findings, decisions and context through the entire system the skeptic can reject an unsupported finding and route the work back before it contaminates the final report, while independent branches keep moving if the run crashes, durable execution resumes from the saved state instead of rebuilding everything, then human-in-the-loop pauses the graph before anything expensive gets sent or published bookmark this repo and watch one prompt turn into an actual org chart for AI agents

Gipp 🦅

11,709 次观看 • 3 个月前

FIVE LAYERS OF AGENT ENGINEERING, EACH ONE WRAPS THE ONE BELOW IT. IF YOU SKIP LAYER 2, YOUR LAYER 5 WILL LOOK BROKEN WHEN IT IS ACTUALLY JUST STANDING ON NOTHING. for weeks i debated harness vs loop vs graph like they were competing choices. then a stack diagram made the shape obvious. they are not choices. they are floors. 01 | prompt engineering. the message. unit of work: one input. inputs are role, instructions, examples, format. output is a single raw response. 02 | context engineering. the memory. unit of work: what stays in the window. a curator selects, compresses, and drops from query, docs, memory, prior turns, and tool outputs before the prompt runs. 03 | harness engineering. the machine. unit of work: the machine itself. gather (context + prompt) → LLM → tools or sub-agents → verifier → final response. the article calls this the operating environment. 04 | loop engineering. the system. unit of work: the run. goal + success criteria + max iterations + budget + completion check wrap around one harness pass. failed pass appends results to context and retries. 05 | graph engineering. the topology. unit of work: the graph run. goal + nodes + edges + state schema. graph routes to agent nodes, tool nodes, or human approval. a reviewer node with a different model and fresh context checks the final answer. the wrapping is the whole point. layer 5 assumes layer 4 works. layer 4 assumes layer 3 works. skip layer 2 and layer 3's verifier keeps failing without a clear reason. this is why swapping the model is a one-day project and swapping the stack is a quarter. the model is the commodity. the five layers around it are the engineering. full three-layer breakdown of the top of the stack (harness, loop, graph) in the post below.

FIVE LAYERS OF AGENT ENGINEERING, EACH ONE WRAPS THE ONE BELOW IT. IF YOU SKIP LAYER 2, YOUR LAYER 5 WILL LOOK BROKEN WHEN IT IS ACTUALLY JUST STANDING ON NOTHING. for weeks i debated harness vs loop vs graph like they were competing choices. then a stack diagram made the shape obvious. they are not choices. they are floors. 01 | prompt engineering. the message. unit of work: one input. inputs are role, instructions, examples, format. output is a single raw response. 02 | context engineering. the memory. unit of work: what stays in the window. a curator selects, compresses, and drops from query, docs, memory, prior turns, and tool outputs before the prompt runs. 03 | harness engineering. the machine. unit of work: the machine itself. gather (context + prompt) → LLM → tools or sub-agents → verifier → final response. the article calls this the operating environment. 04 | loop engineering. the system. unit of work: the run. goal + success criteria + max iterations + budget + completion check wrap around one harness pass. failed pass appends results to context and retries. 05 | graph engineering. the topology. unit of work: the graph run. goal + nodes + edges + state schema. graph routes to agent nodes, tool nodes, or human approval. a reviewer node with a different model and fresh context checks the final answer. the wrapping is the whole point. layer 5 assumes layer 4 works. layer 4 assumes layer 3 works. skip layer 2 and layer 3's verifier keeps failing without a clear reason. this is why swapping the model is a one-day project and swapping the stack is a quarter. the model is the commodity. the five layers around it are the engineering. full three-layer breakdown of the top of the stack (harness, loop, graph) in the post below.

kocer

31,198 次观看 • 1 个月前

People losing so much tokens and have no idea about this: Subagent caches expire in five minutes. In Claude Code, a subagent that sits idle longer than 5 minutes loses its prompt cache. The next call rewrites the whole context from scratch and burns several times more tokens than a cache hit would. Anthropic's guide covers a single setting that stretches that window to an hour: "subagentPromptCacheTtl": "1h" The trade-off is in the write price. Each write to the 1-hour cache costs more than a write to the 5-minute one. You stop paying for a full rewrite every time a subagent pauses, though. For workflows with long gaps between subagent calls, the savings reportedly reach up to 25% of total token spend. Those savings depend heavily on how you work. If your subagents finish fast and rarely sit idle past five minutes, you pay the pricier write for nothing and your bill goes up. Check your own usage before you switch. A comparison script exists that estimates whether the 1-hour TTL saves you money or costs you more on your actual sessions. If your pauses stay under five minutes, keep the default.

People losing so much tokens and have no idea about this: Subagent caches expire in five minutes. In Claude Code, a subagent that sits idle longer than 5 minutes loses its prompt cache. The next call rewrites the whole context from scratch and burns several times more tokens than a cache hit would. Anthropic's guide covers a single setting that stretches that window to an hour: "subagentPromptCacheTtl": "1h" The trade-off is in the write price. Each write to the 1-hour cache costs more than a write to the 5-minute one. You stop paying for a full rewrite every time a subagent pauses, though. For workflows with long gaps between subagent calls, the savings reportedly reach up to 25% of total token spend. Those savings depend heavily on how you work. If your subagents finish fast and rarely sit idle past five minutes, you pay the pricier write for nothing and your bill goes up. Check your own usage before you switch. A comparison script exists that estimates whether the 1-hour TTL saves you money or costs you more on your actual sessions. If your pauses stay under five minutes, keep the default.

Robert Youssef

38,138 次观看 • 15 天前

new skill: create-canvas. last week I made a skill to put every component from a repo on one canvas. I started using it with my agent to create variations, compare ideas, and iterate visually without leaving the codebase. so I made a new skill around that workflow. instead of moving your work into another tool, bring the canvas into your codebase and use it to explore UI with your agent, using the real components, styles, and project context already there.

new skill: create-canvas. last week I made a skill to put every component from a repo on one canvas. I started using it with my agent to create variations, compare ideas, and iterate visually without leaving the codebase. so I made a new skill around that workflow. instead of moving your work into another tool, bring the canvas into your codebase and use it to explore UI with your agent, using the real components, styles, and project context already there.

Ibelick

38,014 次观看 • 8 天前

Introducing side chats, a new way to ask questions and explore ideas without interrupting your main conversation. Each side chat is a durable agent conversation you can @-mention to bring context back into the main thread.

Sensitive content

Introducing side chats, a new way to ask questions and explore ideas without interrupting your main conversation. Each side chat is a durable agent conversation you can @-mention to bring context back into the main thread.

Cursor

436,937 次观看 • 3 个月前

You're still typing every turn The guy who built the tool wrote the loop that types them for him "I don't prompt Claude anymore I write loops that prompt Claude" A loop takes four shapes turn-based, you close it each round goal-based - all tests pass, stop after 5 tries time-based - every 10 min, fix what's red, overnight proactive - CI breaks, agents fix it and open a PR, no human at all A judge closes the loop, not you The prompt was never the unit of work the loop is Full breakdown below

You're still typing every turn The guy who built the tool wrote the loop that types them for him "I don't prompt Claude anymore I write loops that prompt Claude" A loop takes four shapes turn-based, you close it each round goal-based - all tests pass, stop after 5 tries time-based - every 10 min, fix what's red, overnight proactive - CI breaks, agents fix it and open a PR, no human at all A judge closes the loop, not you The prompt was never the unit of work the loop is Full breakdown below

Skaly_Bull

12,558 次观看 • 2 个月前

You can now steer Cursor SDK agents while they run. run.steer() adds your message to the next turn. If a subagent is mid-task, it moves to the background and keeps working.

You can now steer Cursor SDK agents while they run. run.steer() adds your message to the next turn. If a subagent is mid-task, it moves to the background and keeps working.

Cursor

140,995 次观看 • 23 天前

📡Web Scraping is Live in the app and API You can now turn any URL into AI context on Venice Just include a URL in your prompt, and Venice will automatically scrape the page to include as context for your request

📡Web Scraping is Live in the app and API You can now turn any URL into AI context on Venice Just include a URL in your prompt, and Venice will automatically scrape the page to include as context for your request

Venice

40,032 次观看 • 1 年前

an agent is four parts in a loop. you own one. the other three break it. that's why the demo works and prod doesn't. you can't debug what you can't see. 1) the prompt → what you tell the model each turn. you own this one. good. 2) the context window → what it sees right now. the framework fills it with junk, and you never notice until it rots. 3) the tools → what it can do. you own the list, not when or why it fires them. 4) the control flow → what happens next, when to stop. the framework owns this. it's what breaks at 80%. own all four and your agent stops being a magic trick that works on stage and dies on call. this isn't my idea. it's the 12-factor agents guide (24k stars) github: the whole thing every serious builder ends up rewriting their stack around. full breakdown in the article below.

an agent is four parts in a loop. you own one. the other three break it. that's why the demo works and prod doesn't. you can't debug what you can't see. 1) the prompt → what you tell the model each turn. you own this one. good. 2) the context window → what it sees right now. the framework fills it with junk, and you never notice until it rots. 3) the tools → what it can do. you own the list, not when or why it fires them. 4) the control flow → what happens next, when to stop. the framework owns this. it's what breaks at 80%. own all four and your agent stops being a magic trick that works on stage and dies on call. this isn't my idea. it's the 12-factor agents guide (24k stars) github: the whole thing every serious builder ends up rewriting their stack around. full breakdown in the article below.

Hanako

38,387 次观看 • 3 个月前

Your agents are interchangeable but your context shouldn't be. supermemory is the persistent context layer across all your agents Swap the model and keep the memory!

Your agents are interchangeable but your context shouldn't be. supermemory is the persistent context layer across all your agents Swap the model and keep the memory!

supermemory

22,200 次观看 • 1 个月前

If you are trying to understand where AI agents are going, learn harness engineering. A capable model is only one part of an agent system. Once the model begins reading files, calling tools, modifying state and working across many steps, the quality of the system depends increasingly on the software around it. Consider a coding agent working through a large repository. The model can decide that it needs to inspect a file, search for a symbol, make an edit or run a test, but those decisions do not execute themselves. The surrounding runtime has to decide which resources are available, whether the requested action is permitted, how the operation should be performed, what result should be retained, and what information should be presented to the model on the next step. This becomes harder as the run gets longer. As history accumulates, replaying everything can become costly and less effective. The harness has to decide what should remain in context, what should be summarized or retrieved later, and what belongs in persistent state outside the context window. Execution has similar problems. A long-running agent may need to survive an interruption, avoid repeating completed work, enforce permissions around consequential actions, and preserve enough history to reconstruct what happened when the final result is wrong. These are harness problems. The harness is the layer that manages context, tools, execution, state, checkpoints, limits and traces around the model. Harness engineering is the work of designing and improving that layer. Engineers inspect execution traces, evaluate agents on representative tasks, look for recurring failure modes, and then change things such as context selection, tool interfaces, state handling or execution controls. That last part matters because agent failures are often not fixed by changing the model. Sometimes the useful change is in what the model sees, how a tool is exposed, what state is preserved, or what the runtime does after a failed step. As agents take on longer tasks, the demands on this surrounding software grow. Model capability remains essential, but harness engineering is what turns that capability into an execution process that can be controlled, inspected, tested and improved.

If you are trying to understand where AI agents are going, learn harness engineering. A capable model is only one part of an agent system. Once the model begins reading files, calling tools, modifying state and working across many steps, the quality of the system depends increasingly on the software around it. Consider a coding agent working through a large repository. The model can decide that it needs to inspect a file, search for a symbol, make an edit or run a test, but those decisions do not execute themselves. The surrounding runtime has to decide which resources are available, whether the requested action is permitted, how the operation should be performed, what result should be retained, and what information should be presented to the model on the next step. This becomes harder as the run gets longer. As history accumulates, replaying everything can become costly and less effective. The harness has to decide what should remain in context, what should be summarized or retrieved later, and what belongs in persistent state outside the context window. Execution has similar problems. A long-running agent may need to survive an interruption, avoid repeating completed work, enforce permissions around consequential actions, and preserve enough history to reconstruct what happened when the final result is wrong. These are harness problems. The harness is the layer that manages context, tools, execution, state, checkpoints, limits and traces around the model. Harness engineering is the work of designing and improving that layer. Engineers inspect execution traces, evaluate agents on representative tasks, look for recurring failure modes, and then change things such as context selection, tool interfaces, state handling or execution controls. That last part matters because agent failures are often not fixed by changing the model. Sometimes the useful change is in what the model sees, how a tool is exposed, what state is preserved, or what the runtime does after a failed step. As agents take on longer tasks, the demands on this surrounding software grow. Model capability remains essential, but harness engineering is what turns that capability into an execution process that can be controlled, inspected, tested and improved.

Tech with Mak

49,903 次观看 • 1 个月前

THE LOOP ENGINEERING SETUP THAT LETS CLAUDE RUN YOUR WORK FOR HOURS WITHOUT YOU you sit there babysitting it prompt by prompt other people set the loop up once and let Claude plan, act, verify and fix its own work with nobody at the keyboard that gap is the whole skill of loop engineering the 3 resources that actually teach it, in the order i'd read them: > Claude's "Getting started with loops" - the cleanest entry point, straight from the Claude team ↳ > Claude loop engineering: how to build an agent that works while you sleep - the full roadmap from a single prompt to a loop that runs overnight ↳ > the Loop Engineering orange book - the deep conceptual breakdown, for when you want the whole mental model ↳ entry point, then practice, then the concept. that order saves you a week learn this and the work that eats your whole day starts running without you

THE LOOP ENGINEERING SETUP THAT LETS CLAUDE RUN YOUR WORK FOR HOURS WITHOUT YOU you sit there babysitting it prompt by prompt other people set the loop up once and let Claude plan, act, verify and fix its own work with nobody at the keyboard that gap is the whole skill of loop engineering the 3 resources that actually teach it, in the order i'd read them: > Claude's "Getting started with loops" - the cleanest entry point, straight from the Claude team ↳ > Claude loop engineering: how to build an agent that works while you sleep - the full roadmap from a single prompt to a loop that runs overnight ↳ > the Loop Engineering orange book - the deep conceptual breakdown, for when you want the whole mental model ↳ entry point, then practice, then the concept. that order saves you a week learn this and the work that eats your whole day starts running without you

Mr. Buzzoni

18,365 次观看 • 1 个月前

this is the best features for marketers and growth teams who need to run more than three AI workstreams from a single Codex/Claude account ->1“Every complex project, I end up re-explaining context.” Offloop lets you fork one campaign brief into dedicated Subchannels for audience research, positioning, and landing-page copy. Each workstream starts with the source context and continues independently. ->2“I periodically start a new Chat when the context window fills up. Each new Chat starts with no memory of previous ones.” Offloop carries the relevant context into separate Subchannels for SEO, creator outreach, and lifecycle marketing, so every Agent can continue without rebuilding campaign history. ->3“The subagent can interpret inherited parent-thread context as still-active instruction.” Offloop gives paid social, SEO, and experiment analysis their own Subchannels and independent Agent runtimes. Each Agent receives a focused assignment without losing the campaign context.

this is the best features for marketers and growth teams who need to run more than three AI workstreams from a single Codex/Claude account ->1“Every complex project, I end up re-explaining context.” Offloop lets you fork one campaign brief into dedicated Subchannels for audience research, positioning, and landing-page copy. Each workstream starts with the source context and continues independently. ->2“I periodically start a new Chat when the context window fills up. Each new Chat starts with no memory of previous ones.” Offloop carries the relevant context into separate Subchannels for SEO, creator outreach, and lifecycle marketing, so every Agent can continue without rebuilding campaign history. ->3“The subagent can interpret inherited parent-thread context as still-active instruction.” Offloop gives paid social, SEO, and experiment analysis their own Subchannels and independent Agent runtimes. Each Agent receives a focused assignment without losing the campaign context.

Yum⋆₊˚

12,802 次观看 • 2 个月前

Updated the subagents system in my custom Pi extension to include: - Pi subagents - Codex subagents - Claude Code subagents The Pi thread can call and spin up any of them, and instead of just using the "codex exec" or whatever, it'll do a tool call that wraps it up in a first class way. Have a decent UI for them already added in as well. Pi being the main thread then having Codex/Claude Code as tools when needed feels so good. A flow I'm already using a ton is: "Implement feature ___, have a cc fable subagent research and plan out the api design + feature, then have a codex subagent implement it, then have a cc fable subagent do a review/fixes focused on simplicity and correctness" I also have a dynamic workflows extension setup and working, but it's not nearly as polished yet. Probably gonna make the subagent system more robust, then built it around that so u could have a workflow that flows between codex/cc/pi...

Updated the subagents system in my custom Pi extension to include: - Pi subagents - Codex subagents - Claude Code subagents The Pi thread can call and spin up any of them, and instead of just using the "codex exec" or whatever, it'll do a tool call that wraps it up in a first class way. Have a decent UI for them already added in as well. Pi being the main thread then having Codex/Claude Code as tools when needed feels so good. A flow I'm already using a ton is: "Implement feature ___, have a cc fable subagent research and plan out the api design + feature, then have a codex subagent implement it, then have a cc fable subagent do a review/fixes focused on simplicity and correctness" I also have a dynamic workflows extension setup and working, but it's not nearly as polished yet. Probably gonna make the subagent system more robust, then built it around that so u could have a workflow that flows between codex/cc/pi...

Ben Davis

24,827 次观看 • 3 个月前

this AI engineering breakdown from IBM Technology is pure f*cking treasure it explains the role as a connected system 01 Python and APIs give you the surface to build on: services, data, integrations, and the software around the model 02 RAG and embeddings solve the context layer: finding the right information before the model has to reason about it 03 agents turn that context into work: they choose tools, run steps, and move toward an outcome 04 observability closes the feedback loop: traces, metrics, failures, latency, and the evidence needed to improve the system 05 deployment is where the system becomes real: reliability, constraints, and the conditions that let people actually depend on it the model sits inside this architecture the AI engineer connects every layer into one operating loop: build → retrieve → act → observe → ship save this, then build your solo business with an AI employee ⭣

this AI engineering breakdown from IBM Technology is pure f*cking treasure it explains the role as a connected system 01 Python and APIs give you the surface to build on: services, data, integrations, and the software around the model 02 RAG and embeddings solve the context layer: finding the right information before the model has to reason about it 03 agents turn that context into work: they choose tools, run steps, and move toward an outcome 04 observability closes the feedback loop: traces, metrics, failures, latency, and the evidence needed to improve the system 05 deployment is where the system becomes real: reliability, constraints, and the conditions that let people actually depend on it the model sits inside this architecture the AI engineer connects every layer into one operating loop: build → retrieve → act → observe → ship save this, then build your solo business with an AI employee ⭣

beamnxw ./

13,611 次观看 • 1 个月前

this is worth more than most five figure courses 16 claude agents audit an entire repo at once, a second fleet re-checks every finding on fresh context, and the whole thing runs off one diagram instead of a prompt i ran it against my own code and got back 11 endpoints where i never checked who was logged in, 3 of which the verifier threw out before they ever reached me this is Graph Engineering, the layer above prompting, and it runs on the agent you already pay for: - write your plan out, then ask one question at every "and then": does the next step actually read what the previous one produced - the seams that fail that question were never dependencies, so those jobs run at the same time - the arrows that survive are your real edges, and the longest chain of them is your floor that no number of agents shortens - want it faster, cut a false edge instead of adding a worker - fan the independent work out, one agent per item, no shared state between them - send every finding to a separate agent on fresh context, because a model recognises its own writing 73.5% of the time and grades it kinder once it does - make that verifier check a real signal like a passing test, never the worker's own word that it finished - shard the fleet across worktrees so parallel workers stop overwriting each other, one rule frozen into every worker: never git stash, never git reset - merge only what came back verified, into one report instead of twenty open chats the catch is the ceiling. at 95% independent work 16 agents return 9.14x rather than the 16 you would guess, and even 256 only reach 18.6x, because the merge and the verify stay serial however wide you fan coordination itself is free plain code and every agent underneath it is billed, so start at twenty files and widen once it works bookmark this, the whole method with all six ready-to-run graphs is written out in the article ↓

this is worth more than most five figure courses 16 claude agents audit an entire repo at once, a second fleet re-checks every finding on fresh context, and the whole thing runs off one diagram instead of a prompt i ran it against my own code and got back 11 endpoints where i never checked who was logged in, 3 of which the verifier threw out before they ever reached me this is Graph Engineering, the layer above prompting, and it runs on the agent you already pay for: - write your plan out, then ask one question at every "and then": does the next step actually read what the previous one produced - the seams that fail that question were never dependencies, so those jobs run at the same time - the arrows that survive are your real edges, and the longest chain of them is your floor that no number of agents shortens - want it faster, cut a false edge instead of adding a worker - fan the independent work out, one agent per item, no shared state between them - send every finding to a separate agent on fresh context, because a model recognises its own writing 73.5% of the time and grades it kinder once it does - make that verifier check a real signal like a passing test, never the worker's own word that it finished - shard the fleet across worktrees so parallel workers stop overwriting each other, one rule frozen into every worker: never git stash, never git reset - merge only what came back verified, into one report instead of twenty open chats the catch is the ceiling. at 95% independent work 16 agents return 9.14x rather than the 16 you would guess, and even 256 only reach 18.6x, because the merge and the verify stay serial however wide you fan coordination itself is free plain code and every agent underneath it is billed, so start at twenty files and widen once it works bookmark this, the whole method with all six ready-to-run graphs is written out in the article ↓

Argona

157,688 次观看 • 3 个月前

GitHub is becoming f...cking dangerous for AI agents 10 open-source repos that turn one powerful model into an entire autonomous system 01 LangGraph ▸ → stateful agent orchestration 02 PydanticAI ▸ → typed agents + structured outputs BUILD THE CONTROL LAYER 03 Mastra ▸ → agents + workflows + memory 04 Agno ▸ → multi-agent systems GIVE IT CONTEXT 05 Cognee ▸ → data → knowledge → agent memory 06 Graphiti ▸ → knowledge that changes over time GIVE IT A COMPUTER 07 Browser Use ▸ → AI agents that operate websites 08 E2B ▸ → isolated environments for execution KEEP IT ALIVE 09 Langfuse ▸ → traces + evals + observability 10 DeepEval ▸ → test agent behavior before production the architecture: model → context → planner → memory → tools → execution → eval → retry that's the shift happening on GitHub the best repos aren't making another chatbot they're building everything the model needs around it ⭣

GitHub is becoming f...cking dangerous for AI agents 10 open-source repos that turn one powerful model into an entire autonomous system 01 LangGraph ▸ → stateful agent orchestration 02 PydanticAI ▸ → typed agents + structured outputs BUILD THE CONTROL LAYER 03 Mastra ▸ → agents + workflows + memory 04 Agno ▸ → multi-agent systems GIVE IT CONTEXT 05 Cognee ▸ → data → knowledge → agent memory 06 Graphiti ▸ → knowledge that changes over time GIVE IT A COMPUTER 07 Browser Use ▸ → AI agents that operate websites 08 E2B ▸ → isolated environments for execution KEEP IT ALIVE 09 Langfuse ▸ → traces + evals + observability 10 DeepEval ▸ → test agent behavior before production the architecture: model → context → planner → memory → tools → execution → eval → retry that's the shift happening on GitHub the best repos aren't making another chatbot they're building everything the model needs around it ⭣

Lummox

167,982 次观看 • 27 天前

A Closer Look at Alchemist AI v3.5🔎 In v1, one agent handled everything. You’d enter a prompt like “make a snake game” and get a single block of code—one input, one output. v2 introduced multiple agents with specialized roles: prompt refinement, frontend, backend, and review. It brought more structure, but the process was still linear. Each step produced a single output. With v3, a single agent could handle multiple tasks. It generated HTML, CSS, JavaScript, searched for assets, and more—all in one go, while maintaining full context. Now in v3.5, we combine both models. Multiple agents work in parallel, each capable of producing multiple outputs at once. The prompt compiler adapts based on what you're building. A 3D game? It prioritizes game engines, rendering, and mechanics. A website or 2D app? It shifts focus to relevant frameworks and tools. The tool handler can call several services simultaneously, feeding context-aware data into the code generator for real-time execution. From single-output generation to parallel, adaptive workflows. In the next breakdown, we’ll dive into the architecture behind our proprietary engine in v3.5.

A Closer Look at Alchemist AI v3.5🔎 In v1, one agent handled everything. You’d enter a prompt like “make a snake game” and get a single block of code—one input, one output. v2 introduced multiple agents with specialized roles: prompt refinement, frontend, backend, and review. It brought more structure, but the process was still linear. Each step produced a single output. With v3, a single agent could handle multiple tasks. It generated HTML, CSS, JavaScript, searched for assets, and more—all in one go, while maintaining full context. Now in v3.5, we combine both models. Multiple agents work in parallel, each capable of producing multiple outputs at once. The prompt compiler adapts based on what you're building. A 3D game? It prioritizes game engines, rendering, and mechanics. A website or 2D app? It shifts focus to relevant frameworks and tools. The tool handler can call several services simultaneously, feeding context-aware data into the code generator for real-time execution. From single-output generation to parallel, adaptive workflows. In the next breakdown, we’ll dive into the architecture behind our proprietary engine in v3.5.

ALCHEMIST AI 🔮

12,706 次观看 • 1 年前

We've updated /fork in Claude Code /fork now runs a background agent with your exact context (system prompt, tools, history, model) and prompt cache. The result gets returned to your session. /branch (the old /fork) still copies the transcript to a new session you drive.

We've updated /fork in Claude Code /fork now runs a background agent with your exact context (system prompt, tools, history, model) and prompt cache. The result gets returned to your session. /branch (the old /fork) still copies the transcript to a new session you drive.

ClaudeDevs

381,676 次观看 • 4 个月前