Join our daily and weekly newsletters for the latest updates and exclusive content on industry-leading AI coverage. Learn More To date, vibe coding platforms have largely relied on existing large language models (LLMs) to help write code. However, writing code is only one of many different tasks developers need to perform to build a full enterprise-grade production platform. Other tasks in the complete software engineering workflow require using different tools to help review, commit and maintain code over time. It’s a challenge Windsurf (formerly Codeium) is taking on with a series of new frontier AI models it calls SWE-1 (software engineer 1) as part of the company’s Wave 9 update. The news comes as Windsurf is reportedly in the midst of being acquired by AI leader OpenAI for as much as $3 billion. That deal has not yet formally closed, and Windsurf is not currently publicly commenting on the deal. SWE-1 is a family of frontier-class AI models specifically designed to accelerate the entire software engineering process. Unlike general-purpose AI models that have been adapted for coding tasks, the SWE-1 family was built to address the full spectrum of software engineering activities. The new models aim to support developers through multiple surfaces, incomplete work states and long-running tasks that characterize real-world software development. Available immediately to Windsurf users, SWE-1 marks the company’s entry into frontier model development with performance competitive to established foundation models, but with a focus on software engineering workflows. “Our main goal here is to accelerate all software engineering by 99%,” Anshul Ramachandran, head of product and strategy at Windsurf, told VentureBeat.  Enterprise developers need more than just coding-capable models The core innovation behind SWE-1 is Windsurf’s recognition that coding represents only a fraction of what software engineers actually do. This approach addresses a critical limitation in current AI coding LLMs. Many different models can be used today to write application code, including OpenAI’s GPT-4.1, Anthropic Claude 3.7 and Google’s Gemini 2.5 Pro I/O edition.  Windsurf has a modular interface that can enable use of multiple different models. Ramachandran explained that Windsurf users have given the company feedback that existing coding models tend to do well with user guidance, but over time tend to miss things. This limitation stems from a fundamental difference in task structure. While code generation is often a single-shot task, real software engineering involves navigating multiple tools, working with incomplete code and maintaining context across long-running projects. The SWE-1 family: Purpose-built for different engineering tasks Rather than creating a one-size-fits-all solution, Windsurf has developed three specialized models: SWE-1: Full-size model designed for advanced reasoning and tool use, available to all paid users. SWE-1-lite: A smaller but powerful model replacing Windsurf’s existing Cascade Base, available to all users (both free and paid). SWE-1-mini: A lightweight model powering passive code predictions in Windsurf Tab, unlimited for all users. The SWE models were built through an extensive in-house training process focused specifically on software engineering tasks. Ramachandran said that the company used a new data model with sequential steps for training. Performance benchmarks: How SWE-1 compares  While SWE-1 isn’t positioned to replace foundation models from major labs, Windsurf claims it achieves frontier-class performance specifically for software engineering tasks. The company reports that it substantially outperforms mid-sized foundation models and open-weight models. However, Windsurf is careful not to oversell these initial results.  “Even our benchmark shows it’s not objectively better than all the other models,” Ramachandran acknowledged. Instead, the goal is to position SWE-1 as the first step toward purpose-built models that will eventually surpass general-purpose ones for specific engineering tasks — and potentially at a lower cost. What makes Windsurf’s approach technically distinctive is its implementation of the flow awareness concept. The basic idea is that a flow of steps need to happen as part of enterprise development. Rather than just writing code for one specific step, flow awareness is about being aware of the broader context. Flow awareness is centered on creating a shared timeline of actions between humans and AI in software development. The core idea is to progressively transfer tasks from human to AI by understanding where AI can most effectively assist. This approach creates a continuous improvement loop for the models.  “As we continue to improve the models, more of the steps in that shared timeline will be flipped from human to AI,” said Ramachandran. “The AI will be able to do more things that the human had to do before because the AI wasn’t right.” What this means for technical decision-makers For enterprises building or maintaining software, SWE-1 represents an important evolution in AI-assisted development. Rather than treating AI coding assistants as simply autocomplete tools, this approach promises to accelerate the entire development lifecycle. The potential impact extends beyond just writing code more quickly. The recognition that application development is more involved will help mature the vibe coding paradigm to be more applicable for stable enterprise software development. While it’s still early days for SWE-1, this move is important. If and when OpenAI completes the acquisition of Windsurf, the new models could become even more important as they intersect with the larger model research and development resources that will become available. Technical leaders should consider how much of their development workflow could benefit from AI assistance beyond mere code generation. Teams spending significant time on code reviews, debugging and managing technical debt might see more substantial benefits from tools like SWE-1 than those primarily focused on generating new code. Daily insights on business use cases with VB Daily If you want to impress your boss, VB Daily has you covered. We give you the inside scoop on what companies are doing with generative AI, from regulatory shifts to practical deployments, so you can share insights for maximum ROI. Read our Privacy Policy Thanks for subscribing. Check out more VB newsletters here. An error occured.

QA EngineerRobloxSan Mateo, CA, United States1 hour agoApplyEvery day, tens of millions of people come to Roblox to explore, create, play, learn, and connect with friends in 3D immersive digital experiences– all created by our global community of developers and creators.At Roblox, we’re building the tools and platform that empower our community to bring any experience that they can imagine to life. Our vision is to reimagine the way people come together, from anywhere in the world, and on any device. We’re on a mission to connect a billion people with optimism and civility, and looking for amazing talent to help us get there.A career at Roblox means you’ll be working to shape the future of human interaction, solving unique technical challenges at scale, and helping to create safer, more civil shared experiences for everyone.What You’ll Do:Help drive quality engineering efforts for internal and external product releasesHelp develop automated test strategies for existing and new, unreleased featuresDefine/implement/maintain test automation that drives improvements in Roblox usability, performance, hardware compatibility, and software interoperabilityDiagnose, debug, and perform root cause analysis for defects/incidents, document your findings, collaborate cross-functionally to triage, and champion resolution of your bugsCollaborate with Product Design, Program Management, Feature Developers, and other Quality Engineering team members to define requirements, ensure testability, and deliver high-quality featuresParticipate in the release process for RobloxCollaborate with partner teams to understand dependencies and to facilitate development of integration and end-to-end testsProvide technical support to internal team membersYou Are:Proficient in Python, JavaScript, and object-oriented programming using Kotlin, Swift, Objective-C, or similarExperienced with client and/or mobile test automation frameworks (E.g. XCTest/XCUITest, Selenium WebDriver, Appium, Espresso, etc.)Experienced in defining/implementing/maintaining test coverage for a variety of platforms such as iOS, Android, Playstation, Quest VR, Google Chromebook, or similarProficient with version control (E.g. GitHub) and issue/project tracking software (E.g. Jira)Proficient with software development/debugging tools (E.g. Chrome Dev Tools, Postman, Charles Proxy, curl, etc.)Experienced with TestRail or similar test suite/case management toolsExperienced with Jenkins or similar build toolsHave a deep understanding of quality-related agile methodologies and experience applying them throughout the SDLCStrong communication skills (E.g. Whiteboarding/diagramming system behavior)Skilled in analytical thinking, reporting, leadership, customer-centric approaches, and cross-functional collaborationFor roles that are based at our headquarters in San Mateo, CA: The starting base pay for this position is as shown below. The actual base pay is dependent upon a variety of job-related factors such as professional background, training, work experience, location, business needs and market demand. Therefore, in some circumstances, the actual salary could fall outside of this expected range. This pay range is subject to change and may be modified in the future. All full-time employees are also eligible for equity compensation and for benefits.Annual Salary Range$154,570 — $184,100 USDRoles that are based in our San Mateo, CA Headquarters are in-office Tuesday, Wednesday, and Thursday, with optional in-office on Monday and Friday (unless otherwise noted).You’ll Love:Industry-leading compensation packageExcellent medical, dental, and vision coverageA rewarding 401k programFlexible vacation policy (varies by exemption status)Roflex - Flexible and supportive work policyRoblox Admin badge for your avatarAt Roblox HQ:Free catered lunches five times a week and several fully stocked kitchens with unlimited snacksOnsite fitness center and fitness program creditAnnual CalTrain Go PassRoblox provides equal employment opportunities to all employees and applicants for employment and prohibits discrimination and harassment of any type without regard to race, color, religion, age, sex, national origin, disability status, genetics, protected veteran status, sexual orientation, gender identity or expression, or any other characteristic protected by federal, state or local laws. Roblox also provides reasonable accommodations for all candidates during the interview process. Create Your Profile — Game companies can contact you with their relevant job openings. Apply

Join our daily and weekly newsletters for the latest updates and exclusive content on industry-leading AI coverage. Learn More To date, vibe coding platforms have largely relied on existing large language models (LLMs) to help write code. However, writing code is only one of many different tasks developers need to perform to build a full enterprise-grade production platform. Other tasks in the complete software engineering workflow require using different tools to help review, commit and maintain code over time. It’s a challenge Windsurf (formerly Codeium) is taking on with a series of new frontier AI models it calls SWE-1 (software engineer 1) as part of the company’s Wave 9 update. The news comes as Windsurf is reportedly in the midst of being acquired by AI leader OpenAI for as much as $3 billion. That deal has not yet formally closed, and Windsurf is not currently publicly commenting on the deal. SWE-1 is a family of frontier-class AI models specifically designed to accelerate the entire software engineering process. Unlike general-purpose AI models that have been adapted for coding tasks, the SWE-1 family was built to address the full spectrum of software engineering activities. The new models aim to support developers through multiple surfaces, incomplete work states and long-running tasks that characterize real-world software development. Available immediately to Windsurf users, SWE-1 marks the company’s entry into frontier model development with performance competitive to established foundation models, but with a focus on software engineering workflows. “Our main goal here is to accelerate all software engineering by 99%,” Anshul Ramachandran, head of product and strategy at Windsurf, told VentureBeat.  Enterprise developers need more than just coding-capable models The core innovation behind SWE-1 is Windsurf’s recognition that coding represents only a fraction of what software engineers actually do. This approach addresses a critical limitation in current AI coding LLMs. Many different models can be used today to write application code, including OpenAI’s GPT-4.1, Anthropic Claude 3.7 and Google’s Gemini 2.5 Pro I/O edition.  Windsurf has a modular interface that can enable use of multiple different models. Ramachandran explained that Windsurf users have given the company feedback that existing coding models tend to do well with user guidance, but over time tend to miss things. This limitation stems from a fundamental difference in task structure. While code generation is often a single-shot task, real software engineering involves navigating multiple tools, working with incomplete code and maintaining context across long-running projects. The SWE-1 family: Purpose-built for different engineering tasks Rather than creating a one-size-fits-all solution, Windsurf has developed three specialized models: SWE-1: Full-size model designed for advanced reasoning and tool use, available to all paid users. SWE-1-lite: A smaller but powerful model replacing Windsurf’s existing Cascade Base, available to all users (both free and paid). SWE-1-mini: A lightweight model powering passive code predictions in Windsurf Tab, unlimited for all users. The SWE models were built through an extensive in-house training process focused specifically on software engineering tasks. Ramachandran said that the company used a new data model with sequential steps for training. Performance benchmarks: How SWE-1 compares  While SWE-1 isn’t positioned to replace foundation models from major labs, Windsurf claims it achieves frontier-class performance specifically for software engineering tasks. The company reports that it substantially outperforms mid-sized foundation models and open-weight models. However, Windsurf is careful not to oversell these initial results.  “Even our benchmark shows it’s not objectively better than all the other models,” Ramachandran acknowledged. Instead, the goal is to position SWE-1 as the first step toward purpose-built models that will eventually surpass general-purpose ones for specific engineering tasks — and potentially at a lower cost. What makes Windsurf’s approach technically distinctive is its implementation of the flow awareness concept. The basic idea is that a flow of steps need to happen as part of enterprise development. Rather than just writing code for one specific step, flow awareness is about being aware of the broader context. Flow awareness is centered on creating a shared timeline of actions between humans and AI in software development. The core idea is to progressively transfer tasks from human to AI by understanding where AI can most effectively assist. This approach creates a continuous improvement loop for the models.  “As we continue to improve the models, more of the steps in that shared timeline will be flipped from human to AI,” said Ramachandran. “The AI will be able to do more things that the human had to do before because the AI wasn’t right.” What this means for technical decision-makers For enterprises building or maintaining software, SWE-1 represents an important evolution in AI-assisted development. Rather than treating AI coding assistants as simply autocomplete tools, this approach promises to accelerate the entire development lifecycle. The potential impact extends beyond just writing code more quickly. The recognition that application development is more involved will help mature the vibe coding paradigm to be more applicable for stable enterprise software development. While it’s still early days for SWE-1, this move is important. If and when OpenAI completes the acquisition of Windsurf, the new models could become even more important as they intersect with the larger model research and development resources that will become available. Technical leaders should consider how much of their development workflow could benefit from AI assistance beyond mere code generation. Teams spending significant time on code reviews, debugging and managing technical debt might see more substantial benefits from tools like SWE-1 than those primarily focused on generating new code. Daily insights on business use cases with VB Daily If you want to impress your boss, VB Daily has you covered. We give you the inside scoop on what companies are doing with generative AI, from regulatory shifts to practical deployments, so you can share insights for maximum ROI. Read our Privacy Policy Thanks for subscribing. Check out more VB newsletters here. An error occured.

Senior Cinematic ArtistActivisionWarszawa 00-838 Poland1 hour agoApplyJob Title:Senior Cinematic ArtistRequisition ID:R024348Job Description:Position available in Warsaw, Poland or Malmö, Sweden (On-Site Hybrid)Elsewhere Entertainment is looking for a Senior Cinematic Artist to join the development of a new IP.Feed your creativity while driving the development of our game world andstory! Collaborate with our highly skilled team to build somethinginnovative, exhilarating, and expansively entertaining.As a member of the narrative department, you’ll be responsible for realizing and integrating the game's cinematic events and dialogue sequences helping create memorable moments for an epic player driven story. You will also work in constant collaboration with the game/level design team to optimize the execution of game mechanics and properly orient the player in the world.As a member of the project, you’ll help take the studio and our game from great to even better—with a focus on inclusivity, mutual respect (for ourselves and our players), thoughtfulness, empathy, professionalism, and collaboration.You’ll help us by…Participate in developing assets for narrative and script events (gameplay, audio, art) as well as implementation and debugging tasks. Be proficient in narrative tools and systemsWork with the design team in setting up cameras, timelines and events to create the game’s player experienceSupervise or contribute to directing and recording sessions (motion capture, voiceover and performance capture)Supervise certain elements of the narration helping writers and narrative designers improve the storytelling of a sequence (script, voiceover and presentation)Ensure the visibility of game elements in improving the players’ experience of the world.Plan and coordinate cinematic design activitiesIncorporate cinematic and script events into the game engine.You’re awesome because you have…Proven experience (8 years +) designing cinematic and dialogue sequencesTechnical fluency using cinematic and game engine production toolsIn-depth knowledge of the theoretical aspect of camera systems (direction and gameplay)Resourceful, proactive and assertive, you are a good motivatorWith a methodical approach to duties and objectives, you can adhere to production schedulesBonus points for…Familiarity with Premiere and After EffectsEnjoyment of playing a variety of video game genres and titlesFamiliar with cinematics and dialogue presentation methods for narrative driven AAA games.Not sure you meet all the qualifications? Let us decide! Research shows that women and members of other under-represented groups tend to not apply to jobs when they think they may not meet every qualification, when, in fact, they often do! At Activision, we are committed to creating a diverse and inclusive environment and strongly encourage you to apply.Our WorldAt Activision, we strive to create the most iconic brands in gaming and entertainment. We’re driven by our mission to deliver unrivaled gaming experiences for the world to enjoy, together. We are home to some of the most beloved entertainment franchises including Call of Duty®, Crash Bandicoot™, Tony Hawk’s™ Pro Skater™, and Guitar Hero®. As a leading worldwide developer, publisher and distributor of interactive entertainment and products, our “press start” is simple: delight hundreds of millions of players around the world with innovative, fun, thrilling, and engaging entertainment experiences.We’re not just looking back at our decades-long legacy; we’re forging ahead to keep advancing gameplay with some of the most popular titles and sophisticated technology in the world. We have bold ambitions to create the most inclusive company as we know our success comes from the passionate, creative, and diverse teams within our organization.We’re in the business of delivering fun and unforgettable entertainment for our player community to enjoy. And our future opportunities have never been greater — this could be your opportunity to level up.Ready to Activate Your Future?#elsewhere Create Your Profile — Game companies can contact you with their relevant job openings. Apply

Pipeline EngineerEpic GamesLondon, England, United Kingdom1 hour agoApplyWHAT MAKES US EPIC?At the core of Epic’s success are talented, passionate people. Epic prides itself on creating a collaborative, welcoming, and creative environment. Whether it’s building award-winning games or crafting engine technology that enables others to make visually stunning interactive experiences, we’re always innovating.Being Epic means being a part of a team that continually strives to do right by our community and users. We’re constantly innovating to raise the bar of engine and game development.ENGINEERING - UNREAL ENGINEWhat We DoUnreal-powered projects have been on the bleeding edge of real-time entertainment for over 20 years. Our team of engineering experts are always innovating to improve the tools and technology that empower content developers worldwide.What You'll DoWe're looking for a Senior Pipeline Engineer to join our Metahuman organization who will architect and scale our infrastructure for synthetic data generation to advance our research capabilities.In this role, you willBuild and evolve scalable infrastructure for synthetic data generationWork closely with research teams to understand and deliver datasets that drive Metahuman technology forwardEstablish new pipeline capabilities for synthetic dataset generationTroubleshoot and optimize performance across distributed systemsCollaborate cross-functionally to align technical solutions with research requirementsWhat we're looking forProduction experience with Unreal Engine in a pipeline capacity, including expertise with Python and C++ for debugging and interfacing with existing engine systemsStrong understanding of distributed systems and scaling services for big data projectsSelf-starter mindset with ability to work independently and solve complex problemsExcellent collaboration skills to work effectively with research departmentsTechnical pipeline development experience in a production environmentKnowledge of data generation workflows and infrastructure architectureExperience with machine learning systems and workflows (preferred but not required)This role is open to multiple locations in the US (excluding CA, NY, & WA).ABOUT USEpic Games spans across 25 countries with 46 studios and 4,500+ employees globally. For over 25 years, we've been making award-winning games and engine technology that empowers others to make visually stunning games and 3D content that bring environments to life like never before. Epic's award-winning Unreal Engine technology not only provides game developers the ability to build high-fidelity, interactive experiences for PC, console, mobile, and VR, it is also a tool being embraced by content creators across a variety of industries such as media and entertainment, automotive, and architectural design. As we continue to build our Engine technology and develop remarkable games, we strive to build teams of world-class talent.Like what you hear? Come be a part of something Epic!Epic Games deeply values diverse teams and an inclusive work culture, and we are proud to be an Equal Opportunity employer. Learn more about our Equal Employment Opportunity (EEO) Policy here.Note to Recruitment Agencies: Epic does not accept any unsolicited resumes or approaches from any unauthorized third party (including recruitment or placement agencies) (i.e., a third party with whom we do not have a negotiated and validly executed agreement). We will not pay any fees to any unauthorized third party. Further details on these matters can be found here. Create Your Profile — Game companies can contact you with their relevant job openings. Apply

In this tutorial, we demonstrate how to construct an automated Knowledge Graph (KG) pipeline using LangGraph and NetworkX. The pipeline simulates a sequence of intelligent agents that collaboratively perform tasks such as data gathering, entity extraction, relation identification, entity resolution, and graph validation. Starting from a user-provided topic, such as “Artificial Intelligence,” the system methodically extracts relevant entities and relationships, resolves duplicates, and integrates the information into a cohesive graphical structure. By visualizing the final knowledge graph, developers and data scientists gain clear insights into complex interrelations among concepts, making this approach highly beneficial for applications in semantic analysis, natural language processing, and knowledge management. !pip install langgraph langchain_core We install two essential Python libraries: LangGraph, which is used for creating and orchestrating agent-based computational workflows, and LangChain Core, which provides foundational classes and utilities for building language model-powered applications. These libraries enable seamless integration of agents into intelligent data pipelines. import re import networkx as nx import matplotlib.pyplot as plt from typing import TypedDict, List, Tuple, Dict, Any from langchain_core.messages import HumanMessage, AIMessage from langgraph.graph import StateGraph, END We import essential libraries to build an automated knowledge graph pipeline. It includes re for regular expression-based text processing, NetworkX and matplotlib for creating and visualizing graphs, TypedDict and typing annotations for structured data handling, and LangGraph along with langchain_core for orchestrating the interaction between AI agents within the workflow. class KGState(TypedDict): topic: str raw_text: str entities: List[str] relations: List[Tuple[str, str, str]] resolved_relations: List[Tuple[str, str, str]] graph: Any validation: Dict[str, Any] messages: List[Any] current_agent: str We define a structured data type, KGState, using Python’s TypedDict. It outlines the schema for managing state across different steps of the knowledge graph pipeline. It includes details like the chosen topic, gathered text, identified entities and relationships, resolved duplicates, the constructed graph object, validation results, interaction messages, and tracking the currently active agent. def data_gatherer(state: KGState) -> KGState: topic = state["topic"] print(f"📚 Data Gatherer: Searching for information about '{topic}'") collected_text = f"{topic} is an important concept. It relates to various entities like EntityA, EntityB, and EntityC. EntityA influences EntityB. EntityC is a type of EntityB." state["messages"].append(AIMessage(content=f"Collected raw text about {topic}")) state["raw_text"] = collected_text state["current_agent"] = "entity_extractor" return state This function, data_gatherer, acts as the first step in the pipeline. It simulates gathering raw text data about a provided topic (stored in state[“topic”]). It then stores this simulated data into state[“raw_text”], adds a message indicating the data collection completion, and updates the pipeline’s state by setting the next agent (entity_extractor) as active. def entity_extractor(state: KGState) -> KGState: print("🔍 Entity Extractor: Identifying entities in the text") text = state["raw_text"] entities = re.findall(r"Entity[A-Z]", text) entities = [state["topic"]] + entities state["entities"] = list(set(entities)) state["messages"].append(AIMessage(content=f"Extracted entities: {state['entities']}")) print(f" Found entities: {state['entities']}") state["current_agent"] = "relation_extractor" return state The entity_extractor function identifies entities from the collected raw text using a simple regular expression pattern that matches terms like “EntityA”, “EntityB”, etc. It also includes the main topic as an entity and ensures uniqueness by converting the list to a set. The extracted entities are stored in the state, an AI message logs the result, and the pipeline advances to the relation_extractor agent. def relation_extractor(state: KGState) -> KGState: print("🔗 Relation Extractor: Identifying relationships between entities") text = state["raw_text"] entities = state["entities"] relations = [] relation_patterns = [ (r"([A-Za-z]+) relates to ([A-Za-z]+)", "relates_to"), (r"([A-Za-z]+) influences ([A-Za-z]+)", "influences"), (r"([A-Za-z]+) is a type of ([A-Za-z]+)", "is_type_of") ] for e1 in entities: for e2 in entities: if e1 != e2: for pattern, rel_type in relation_patterns: if re.search(f"{e1}.*{rel_type}.*{e2}", text.replace("_", " "), re.IGNORECASE) or \ re.search(f"{e1}.*{e2}", text, re.IGNORECASE): relations.append((e1, rel_type, e2)) state["relations"] = relations state["messages"].append(AIMessage(content=f"Extracted relations: {relations}")) print(f" Found relations: {relations}") state["current_agent"] = "entity_resolver" return state The relation_extractor function detects semantic relationships between entities within the raw text. It uses predefined regex patterns to identify phrases like “influences” or “is a type of” between entity pairs. When a match is found, it adds the corresponding relation as a triple (subject, predicate, object) to the relations list. These extracted relations are stored in the state, a message is logged for agent communication, and control moves to the next agent: entity_resolver. def entity_resolver(state: KGState) -> KGState: print("🔄 Entity Resolver: Resolving duplicate entities") entity_map = {} for entity in state["entities"]: canonical_name = entity.lower().replace(" ", "_") entity_map[entity] = canonical_name resolved_relations = [] for s, p, o in state["relations"]: s_resolved = entity_map.get(s, s) o_resolved = entity_map.get(o, o) resolved_relations.append((s_resolved, p, o_resolved)) state["resolved_relations"] = resolved_relations state["messages"].append(AIMessage(content=f"Resolved relations: {resolved_relations}")) state["current_agent"] = "graph_integrator" return state The entity_resolver function standardizes entity names to avoid duplication and inconsistencies. It creates a mapping (entity_map) by converting each entity to lowercase and replacing spaces with underscores. Then, this mapping is applied to all subjects and objects in the extracted relations to produce resolved relations. These normalized triples are added to the state, a confirmation message is logged, and control is passed to the graph_integrator agent. def graph_integrator(state: KGState) -> KGState: print("📊 Graph Integrator: Building the knowledge graph") G = nx.DiGraph() for s, p, o in state["resolved_relations"]: if not G.has_node(s): G.add_node(s) if not G.has_node(o): G.add_node(o) G.add_edge(s, o, relation=p) state["graph"] = G state["messages"].append(AIMessage(content=f"Built graph with {len(G.nodes)} nodes and {len(G.edges)} edges")) state["current_agent"] = "graph_validator" return state The graph_integrator function constructs the actual knowledge graph using networkx.DiGraph() supports directed relationships. It iterates over the resolved triples (subject, predicate, object), ensures both nodes exist, and then adds a directed edge with the relation as metadata. The resulting graph is saved in the state, a summary message is appended, and the pipeline transitions to the graph_validator agent for final validation. def graph_validator(state: KGState) -> KGState: print("✅ Graph Validator: Validating knowledge graph") G = state["graph"] validation_report = { "num_nodes": len(G.nodes), "num_edges": len(G.edges), "is_connected": nx.is_weakly_connected(G) if G.nodes else False, "has_cycles": not nx.is_directed_acyclic_graph(G) if G.nodes else False } state["validation"] = validation_report state["messages"].append(AIMessage(content=f"Validation report: {validation_report}")) print(f" Validation report: {validation_report}") state["current_agent"] = END return state The graph_validator function performs a basic health check on the constructed knowledge graph. It compiles a validation report containing the number of nodes and edges, whether the graph is weakly connected (i.e., every node is reachable if direction is ignored), and whether the graph contains cycles. This report is added to the state and logged as an AI message. Once validation is complete, the pipeline is marked as finished by setting the current_agent to END. def router(state: KGState) -> str: return state["current_agent"] def visualize_graph(graph): plt.figure(figsize=(10, 6)) pos = nx.spring_layout(graph) nx.draw(graph, pos, with_labels=True, node_color='skyblue', node_size=1500, font_size=10) edge_labels = nx.get_edge_attributes(graph, 'relation') nx.draw_networkx_edge_labels(graph, pos, edge_labels=edge_labels) plt.title("Knowledge Graph") plt.tight_layout() plt.show() The router function directs the pipeline to the next agent based on the current_agent field in the state. Meanwhile, the visualize_graph function uses matplotlib and networkx to display the final knowledge graph, showing nodes, edges, and labeled relationships for intuitive visual understanding. def build_kg_graph(): workflow = StateGraph(KGState) workflow.add_node("data_gatherer", data_gatherer) workflow.add_node("entity_extractor", entity_extractor) workflow.add_node("relation_extractor", relation_extractor) workflow.add_node("entity_resolver", entity_resolver) workflow.add_node("graph_integrator", graph_integrator) workflow.add_node("graph_validator", graph_validator) workflow.add_conditional_edges("data_gatherer", router, {"entity_extractor": "entity_extractor"}) workflow.add_conditional_edges("entity_extractor", router, {"relation_extractor": "relation_extractor"}) workflow.add_conditional_edges("relation_extractor", router, {"entity_resolver": "entity_resolver"}) workflow.add_conditional_edges("entity_resolver", router, {"graph_integrator": "graph_integrator"}) workflow.add_conditional_edges("graph_integrator", router, {"graph_validator": "graph_validator"}) workflow.add_conditional_edges("graph_validator", router, {END: END}) workflow.set_entry_point("data_gatherer") return workflow.compile() The build_kg_graph function defines the complete knowledge graph workflow using LangGraph. It sequentially adds each agent as a node, from data collection to graph validation, and connects them through conditional transitions based on the current agent. The entry point is set to data_gatherer, and the graph is compiled into an executable workflow that guides the automated pipeline from start to finish. def run_knowledge_graph_pipeline(topic): print(f"🚀 Starting knowledge graph pipeline for: {topic}") initial_state = { "topic": topic, "raw_text": "", "entities": [], "relations": [], "resolved_relations": [], "graph": None, "validation": {}, "messages": [HumanMessage(content=f"Build a knowledge graph about {topic}")], "current_agent": "data_gatherer" } kg_app = build_kg_graph() final_state = kg_app.invoke(initial_state) print(f"✨ Knowledge graph construction complete for: {topic}") return final_state The run_knowledge_graph_pipeline function initializes the pipeline by setting up an empty state dictionary with the provided topic. It builds the workflow using build_kg_graph(), then runs it by invoking the compiled graph with the initial state. As each agent processes the data, the state evolves, and the final result contains the complete knowledge graph, validated and ready for use. if __name__ == "__main__": topic = "Artificial Intelligence" result = run_knowledge_graph_pipeline(topic) visualize_graph(result["graph"]) Finally, this block serves as the script’s entry point. When executed directly, it triggers the knowledge graph pipeline for the topic “Artificial Intelligence,” runs through all agent stages, and finally visualizes the resulting graph using the visualize_graph() function. It provides an end-to-end demonstration of automated knowledge graph generation. Output Generated from Knowledge Graph Execution In conclusion, we have learned how to seamlessly integrate multiple specialized agents into a cohesive knowledge graph pipeline through this structured approach, leveraging LangGraph and NetworkX. This workflow automates entity and relation extraction processes and visualizes intricate relationships, offering a clear and actionable representation of gathered information. By adjusting and enhancing individual agents, such as employing more sophisticated entity recognition methods or integrating real-time data sources, this foundational framework can be scaled and customized for advanced knowledge graph construction tasks across various domains. Check out the Colab Notebook. All credit for this research goes to the researchers of this project. Also, feel free to follow us on Twitter and don’t forget to join our 90k+ ML SubReddit. Asif RazzaqWebsite |  + postsBioAsif Razzaq is the CEO of Marktechpost Media Inc.. As a visionary entrepreneur and engineer, Asif is committed to harnessing the potential of Artificial Intelligence for social good. His most recent endeavor is the launch of an Artificial Intelligence Media Platform, Marktechpost, which stands out for its in-depth coverage of machine learning and deep learning news that is both technically sound and easily understandable by a wide audience. The platform boasts of over 2 million monthly views, illustrating its popularity among audiences.Asif Razzaqhttps://www.marktechpost.com/author/6flvq/Google DeepMind Introduces AlphaEvolve: A Gemini-Powered Coding AI Agent for Algorithm Discovery and Scientific OptimizationAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Rime Introduces Arcana and Rimecaster (Open Source): Practical Voice AI Tools Built on Real-World SpeechAsif Razzaqhttps://www.marktechpost.com/author/6flvq/A Step-by-Step Guide to Build a Fast Semantic Search and RAG QA Engine on Web-Scraped Data Using Together AI Embeddings, FAISS Retrieval, and LangChainAsif Razzaqhttps://www.marktechpost.com/author/6flvq/Agent-Based Debugging Gets a Cost-Effective Alternative: Salesforce AI Presents SWERank for Accurate and Scalable Software Issue Localization

Are you building a cooperative multiplayer game with Unity? We’ve got the perfect on-demand resource for you: A four-part webinar series from the Multiplayer team – now available on YouTube. This series dives into the Boss Room sample game to explore how you can build a production-ready multiplayer game with Unity and Netcode for GameObjects.Creating multiplayer games isn’t just about using the right APIs. The first episode in the series covers best practices and provides advice when introducing a chaotic tech like the internet between your players when developing a multiplayer game.In the first episode, we cover:What is Netcode for GameObjects (NGO) and Unity Gaming Services (UGS)?NetworkVariables vs RPCs and reasons to choose which for each featureAuthority and why we chose server authority for most of our gameplayMovements and alternative models like Client Authority for dealing with lag, and optimization tricks for pathfinding-based movementsBasic game implementation and how we used State (netvar, network list) and RPCsEpisode two covers the implementation of character abilities in Boss Room and how to approach ability implementation in your game.We dive into:The general flow of implementing server-driven abilitiesReliability and what it means for RPCs to be unreliableMelee attacks and the anticipation of animation issuesTank shield functionality and interaction with the environmentArcher powershots and Area of Effect (AOE), which require tracking inputs over time on the client side onlyMage firebolt and bandwidth useThe general architecture of our ability systemWe also look at:Dynamically spawned objectsSpawning static in-scene placed objectsSpawning destroyable in-scene placed objectsLessons learned around zombie imps when late joiningCustom spawning logic like pools and how to integrate them with NGOIn the third session, we cover a few more game implementation details before diving into making your multiplayer game resilient to players.We explore:Physics interactions, objects and parenting, scenes and scene managementUsing Relay and Lobby to take your game online and why you can’t use NGO for joining playersCharacter selection screen syncing between players using NGO and custom serializationMaking your game resilient to players coming and going, and reconnection flows, late join support, disconnection, and timeoutsHandling race conditions and various tests to performIn the fourth and final session of the series, we explore game development best practices for multiplayer games.This episode covers:Bandwidth optimizations and tools to profile, optimizing NetworkTransforms, and other tipsDebugging tools like network condition simulators, stats monitoring, and custom debug flowsProject architecture (action system, player architecture, etc.)The future of Boss RoomWatch the series? Share your feedback so we can plan even better sessions in the future.If you’re ready to dive into your next multiplayer project with Unity and Netcode for GameObjects, here are some helpful resources to get you started:Learn more about Netcode for GameObjectsExplore our samples: 3D Boss Room, 2D Galactic Kittens, Bitesize SamplesRead the documentationGot questions or feedback about multiplayer game development in Unity? Feel free to join the discussion on Discord or in the forums.

Machine learning engineering (MLE) involves developing, tuning, and deploying machine learning systems that require iterative experimentation, model optimization, and robust handling of data pipelines. As model complexity increases, so do the challenges associated with orchestrating end-to-end workflows efficiently. Researchers have explored the automation of MLE tasks using AI agents to handle these demands. Large Language Models (LLMs), particularly those with strong coding and problem-solving abilities, have shown potential to enhance this process significantly. Their role in automating structured workflows is now being tested through rigorous benchmarks and environments tailored to emulate real-world MLE scenarios. A primary hurdle in automating machine learning engineering lies in the work’s inherently iterative and feedback-driven nature. Tasks such as hyperparameter tuning, model debugging, and data preprocessing cannot be resolved in one step; they require repeated modifications and evaluations. Traditional evaluation tools for AI models often rely on static datasets and do not allow for real-time error feedback or interactive problem-solving. This limitation prevents LLM agents from learning through trial and error, an essential component for mastering engineering tasks that evolve or require multiple attempts for success. Earlier tools to evaluate LLMs in engineering or coding tasks have mostly focused on individual subtasks or isolated challenges. These include tools like MLAgentBench and DSBench, which rely on narrow test cases sourced from Kaggle competitions or synthetic datasets. While they cover more than basic tasks, they do not enable agents to perform code execution, debugging, or results interpretation in a live setting. Other environments, like SWE-Gym, focus exclusively on software engineering and lack support for machine learning-specific workflows. These limitations have slowed the creation of versatile, high-performing MLE agents that can handle real-time project complexities. Researchers from Georgia Institute of Technology and Stanford University have introduced MLE-Dojo, a framework with an interactive environment that connects LLM agents with real-world machine learning tasks derived from over 200 Kaggle competitions. This framework supports tabular data analysis, computer vision, natural language processing, and time-series forecasting challenges. Research introduced MLE-Dojo to allow agents to write, execute, and revise code in a sandboxed, feedback-rich setting. The goal was to replicate the interactive cycles that human engineers follow, enabling structured learning for agents. The environment includes pre-installed dependencies, evaluation metrics, and supports supervised fine-tuning and reinforcement learning strategies. MLE-Dojo’s structure consists of modular components that support a wide range of MLE challenges. Each task runs within its own Docker container, isolating it for safety and reproducibility. Agents interact with the environment through a Partially Observable Markov Decision Process, receiving observations, performing actions, and gaining rewards based on performance. The environment supports five primary action types: requesting task information, validating code, executing code, retrieving interaction history, and resetting the environment. It also provides a detailed observation space that includes datasets, execution results, and error messages. The agent receives structured feedback after every interaction, allowing for step-wise improvement. This modular setup helps maintain interoperability and simplifies adding new tasks to the system. The evaluation included eight frontier LLMs—Gemini-2.5-Pro, DeepSeek-r1, o3-mini, GPT-4o, GPT-4o-mini, Gemini-2.0-Pro, Gemini-2.0-Flash, and DeepSeek-v3—across four core machine learning domains. Gemini-2.5-Pro achieved the highest Elo rating of 1257, followed by DeepSeek-r1 at 1137 and o3-mini at 1108. Regarding HumanRank, Gemini-2.5-Pro led with 61.95%, indicating its superior performance over human benchmarks. Models like GPT-4o-mini executed code only 20% of the time, adopting conservative strategies, while o3-mini performed executions in over 90% of the cases. The average failure rate for Gemini-2.5-Pro remained the lowest across validation and execution phases, reinforcing its robustness. Among domains, computer vision posed the greatest challenge, with most models scoring under 60 in HumanRank. Reasoning models generally produced longer outputs and maintained stronger performance consistency across iterations. The research highlights the difficulty of applying LLMs to full machine learning workflows. It outlines a comprehensive solution in MLE-Dojo that enables learning through interaction, not just completion. MLE-Dojo sets a new standard for training and evaluating autonomous MLE agents by simulating engineering environments more accurately. Check out theTwitter and don’t forget to join our 90k+ ML SubReddit. NikhilNikhil is an intern consultant at Marktechpost. He is pursuing an integrated dual degree in Materials at the Indian Institute of Technology, Kharagpur. Nikhil is an AI/ML enthusiast who is always researching applications in fields like biomaterials and biomedical science. With a strong background in Material Science, he is exploring new advancements and creating opportunities to contribute.Nikhilhttps://www.marktechpost.com/author/nikhil0980/This AI Paper Investigates Test-Time Scaling of English-Centric RLMs for Enhanced Multilingual Reasoning and Domain GeneralizationNikhilhttps://www.marktechpost.com/author/nikhil0980/PwC Releases Executive Guide on Agentic AI: A Strategic Blueprint for Deploying Autonomous Multi-Agent Systems in the EnterpriseNikhilhttps://www.marktechpost.com/author/nikhil0980/Multimodal AI Needs More Than Modality Support: Researchers Propose General-Level and General-Bench to Evaluate True Synergy in Generalist ModelsNikhilhttps://www.marktechpost.com/author/nikhil0980/This AI Paper Introduces Effective State-Size (ESS): A Metric to Quantify Memory Utilization in Sequence Models for Performance Optimization

OpenAI has made GPT-4.1 more widely available, as ChatGPT Plus, Pro, and Team users can now access the AI model.  On Wednesday, the brand announced that it brought the model to its direct chatbot service following its original launch, where it was unveiled as an API in April. Its popularity among developers urged OpenAI to make the model available for paid users. It also plans to roll out GPT-4.1 for ChatGPT Enterprise and Edu users in the coming weeks.  Recommended Videos Paid users will be able to find the model within the “more models” dropdown menu of ChatGPT as of Wednesday.  Related The highlight features of GPT-4.1 are coding and web development tasks. The model can assist you in writing or debugging code, and OpenAI said in April that it shows significant improvements in comparison to GPT-4o and GPT-4o mini. These updates also follow OpenAI making adjustments to its model lineup, which includes its retiring GPT-4 and sunsetting the GPT 4.5 models. The brand announced the GPT-4.1 API not long after that, noting its capabilities as its fastest and cheapest model. Additionally, the model is knowledgeable up to June 2024. OpenAI has collaborated with companies including Windsurf, Qodo, Hex, Blue J, Thomson Reuters, and Carlyle using the GPT-4.1 API. OpenAI also detailed that it has now put GPT-4.1 mini in place of GPT-4o mini for all ChatGPT tiers, including the free option. The brand noted that this option will also be included under the “more models” dropdown menu for paid users. It will also be the base model for free users after they surpass GPT-4o usage limits.  Notably, a ChatGPT Plus subscription goes for $20 per month, while a ChatGPT Pro plan goes for a steep $200 per month. A ChatGPT Team subscription is $25 per person per month annually, for two or more users.